solarwinds_apm 5.0.0

data/lib/solarwinds_apm/inst/delayed_job.rb

@@ -0,0 +1,100 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+if defined?(Delayed)
+  module SolarWindsAPM
+    module Inst
+      module DelayedJob
+        ##
+        # ForkHandler
+        #
+        # Since delayed job doesn't offer a hook into `after_fork`, we alias the method
+        # here to do our magic after a fork happens.
+        #
+        module ForkHandler
+          def self.extended(klass)
+            SolarWindsAPM::Util.class_method_alias(klass, :after_fork, ::Delayed::Worker)
+          end
+
+          def after_fork_with_sw_apm
+            SolarWindsAPM.logger.info '[solarwinds_apm/delayed_job] Detected fork.  Restarting SolarWindsAPM reporter.' if SolarWindsAPM::Config[:verbose]
+            SolarWindsAPM::Reporter.restart unless ENV.key?('SW_APM_GEM_TEST')
+
+            after_fork_without_sw_apm
+          end
+        end
+
+        ##
+        # SolarWindsAPM::Inst::DelayedJob::Plugin
+        #
+        # The SolarWindsAPM DelayedJob plugin.  Here we wrap `enqueue` and
+        # `perform` to capture the timing of the bits we're interested in.
+        #
+        # Traces from the client are not continued in the consumer for a number
+        # of reasons:
+        # - no context propagation for delayed_job in OTEL
+        # - there is no reliable way to for the job to carry trace information. It
+        #   is an instance of a shared class they share,
+        #   often: Delayed::Backend::ActiveRecord::Job, but could be something else
+        # - It can also be too asynchronous for tracing to make sense. The worker can be
+        #   delayed by seconds/minutes/hours and the trace processing completed already
+        #
+        class Plugin < Delayed::Plugin
+          callbacks do |lifecycle|
+
+            # enqueue
+            if SolarWindsAPM::Config[:delayed_jobclient][:enabled]
+              lifecycle.around(:enqueue) do |job, &block|
+                begin
+                  report_kvs = {}
+                  report_kvs[:Spec] = :pushq
+                  report_kvs[:Flavor] = :DelayedJob
+                  report_kvs[:JobName] = job.name
+                  report_kvs[:MsgID] = job.id
+                  report_kvs[:Queue] = job.queue if job.queue
+                  report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:delayed_jobclient][:collect_backtraces]
+
+                  SolarWindsAPM::SDK.trace(:'delayed_job-client', kvs: report_kvs) do
+                    block.call(job)
+                  end
+                end
+              end
+            end
+
+            # invoke_job
+            if SolarWindsAPM::Config[:delayed_jobworker][:enabled]
+              lifecycle.around(:perform) do |worker, job, &block|
+                begin
+                  report_kvs = {}
+                  report_kvs[:Spec] = :job
+                  report_kvs[:Flavor] = :DelayedJob
+                  report_kvs[:JobName] = job.name
+                  report_kvs[:MsgID] = job.id
+                  report_kvs[:Queue] = job.queue if job.queue
+                  report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:delayed_jobworker][:collect_backtraces]
+
+                  # DelayedJob Specific KVs
+                  report_kvs[:priority] = job.priority
+                  report_kvs[:attempts] = job.attempts
+                  report_kvs[:WorkerName] = job.locked_by
+                rescue => e
+                  SolarWindsAPM.logger.warn "[solarwinds_apm/warning] inst/delayed_job.rb: #{e.message}"
+                end
+
+                SolarWindsAPM::SDK.start_trace(:'delayed_job-worker', kvs: report_kvs) do
+                  result = block.call(worker, job)
+                  SolarWindsAPM::API.log_exception(:'delayed_job-worker', job.error) if job.error
+                  result
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting delayed_job' if SolarWindsAPM::Config[:verbose]
+  SolarWindsAPM::Util.send_extend(::Delayed::Worker, SolarWindsAPM::Inst::DelayedJob::ForkHandler)
+  Delayed::Worker.plugins << SolarWindsAPM::Inst::DelayedJob::Plugin
+end

data/lib/solarwinds_apm/inst/excon.rb

@@ -0,0 +1,113 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module Inst
+    module ExconConnection
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      private
+
+      def sw_apm_collect(params)
+        kvs = {}
+        kvs[:Spec] = 'rsc'
+        kvs[:IsService] = 1
+
+        # Conditionally log query args
+        if SolarWindsAPM::Config[:excon][:log_args] && @data[:query]
+          if @data[:query].is_a?(Hash)
+            service_arg = "#{@data[:path]}?#{URI.encode_www_form(@data[:query])}"
+          else
+            service_arg = "#{@data[:path]}?#{@data[:query]}"
+          end
+        else
+          service_arg = @data[:path]
+        end
+        kvs[:RemoteURL] = "#{@data[:scheme]}://#{@data[:host]}:#{@data[:port]}#{service_arg}"
+
+        # In the case of HTTP pipelining, params could be an array of
+        # request hashes.
+        if params.is_a?(Array)
+          methods = []
+          params.each do |p|
+            methods << SolarWindsAPM::Util.upcase(p[:method])
+          end
+          kvs[:HTTPMethods] = methods.join(',')[0..1024]
+          kvs[:Pipeline] = true
+        else
+          kvs[:HTTPMethod] = SolarWindsAPM::Util.upcase(params[:method])
+        end
+        kvs
+      rescue => e
+        SolarWindsAPM.logger.debug "[solarwinds_apm/debug] Error capturing excon KVs: #{e.message}"
+        SolarWindsAPM.logger.debug e.backtrace.join('\n') if SolarWindsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      public
+
+      def requests(pipeline_params)
+        responses = nil
+        kvs = sw_apm_collect(pipeline_params)
+        SolarWindsAPM::SDK.trace(:excon, kvs: kvs) do
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:excon][:collect_backtraces]
+          responses = super(pipeline_params)
+          kvs[:HTTPStatuses] = responses.map { |r| r.status }.join(',')
+        end
+        responses
+      end
+
+      def request(params = {}, &block)
+        # If we're not tracing, just do a fast return.
+        # If making HTTP pipeline requests (ordered batched)
+        # then just return as we're tracing from parent
+        # <tt>requests</tt>
+        if !SolarWindsAPM.tracing? || params[:pipeline]
+          add_tracecontext_headers(@data[:headers])
+          return super(params, &block)
+        end
+
+        begin
+          response_context = nil
+
+          kvs = sw_apm_collect(params)
+
+          SolarWindsAPM::API.log_entry(:excon, kvs)
+          kvs.clear
+
+          req_context = SolarWindsAPM::Context.toString
+
+          # The core excon call
+          add_tracecontext_headers(@data[:headers])
+          response = super(params, &block)
+
+          # excon only passes back a hash (datum) for HTTP pipelining...
+          # In that case, we should never arrive here but for the OCD, double check
+          # the datatype before trying to extract pertinent info
+          if response.is_a?(Excon::Response)
+            kvs[:HTTPStatus] = response.status
+
+            # If we get a redirect, report the location header
+            if ((300..308).to_a.include? response.status.to_i) && response.headers.key?('Location')
+              kvs[:Location] = response.headers['Location']
+            end
+          end
+
+          response
+        rescue => e
+          SolarWindsAPM::API.log_exception(:excon, e)
+          raise e
+        ensure
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:excon][:collect_backtraces]
+          SolarWindsAPM::API.log_exit(:excon, kvs) unless params[:pipeline]
+        end
+      end
+    end
+  end
+end
+
+if SolarWindsAPM::Config[:excon][:enabled] && defined?(Excon)
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting excon' if SolarWindsAPM::Config[:verbose]
+  Excon::Connection.prepend(SolarWindsAPM::Inst::ExconConnection)
+end

data/lib/solarwinds_apm/inst/faraday.rb

@@ -0,0 +1,96 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+#####################################################
+# FYI:
+# Faraday only adds tracing when it is
+# not using an adapter that is instrumented
+#
+# otherwise we would get two spans for the same call
+#####################################################
+
+module SolarWindsAPM
+  module Inst
+    module FaradayConnection
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      def run_request(method, url, body, headers, &block)
+        remote_call = remote_call?
+        unless SolarWindsAPM.tracing?
+          if remote_call
+            add_tracecontext_headers(@headers)
+          end
+          return super(method, url, body, headers, &block)
+        end
+
+        begin
+          SolarWindsAPM::API.log_entry(:faraday)
+          if remote_call # nothing else is instrumented that could add the w3c context
+            add_tracecontext_headers(@headers)
+          end
+
+          result = super(method, url, body, headers, &block)
+
+          kvs = {}
+
+          # this seems the safer condition than trying to identify the
+          # faraday version when adapter started to work without arg
+          # and handlers don't include the adapter anymore
+          if @builder.method(:adapter).parameters.find { |ele| ele[0] == :req }
+            kvs[:Middleware] = @builder.handlers
+          else
+            kvs[:Middleware] = [@builder.adapter] + @builder.handlers
+          end
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:faraday][:collect_backtraces]
+
+          # Only send service KVs if we're not using an adapter
+          # Otherwise, the adapter instrumentation will send the service KVs
+          if remote_call
+            kvs.merge!(rsc_kvs(url, method, result))
+          end
+
+          result
+        rescue => e
+          SolarWindsAPM::API.log_exception(:faraday, e)
+          raise e
+        ensure
+          SolarWindsAPM::API.log_exit(:faraday, kvs)
+        end
+      end
+
+      private
+
+      # This is only considered a remote service call if the middleware/adapter is not instrumented
+      def remote_call?
+        if @builder.method(:adapter).parameters.find { |ele| ele[0] == :req }
+          (@builder.handlers.map(&:name) & SW_APM_INSTR_ADAPTERS).count == 0
+        else
+          ((@builder.handlers.map(&:name) << @builder.adapter.name) & SW_APM_INSTR_ADAPTERS).count == 0
+        end
+      end
+
+      def rsc_kvs(_url, method, result)
+        kvs = { :Spec => 'rsc',
+                :IsService => 1,
+                :HTTPMethod => method.upcase,
+                :HTTPStatus => result.status, }
+        kvs[:RemoteURL] = result.env.to_hash[:url].to_s
+        kvs[:RemoteURL].split('?').first unless SolarWindsAPM::Config[:faraday][:log_args]
+
+        kvs
+      end
+    end
+  end
+end
+
+if defined?(Faraday) && SolarWindsAPM::Config[:faraday][:enabled]
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting faraday' if SolarWindsAPM::Config[:verbose]
+  Faraday::Connection.prepend(SolarWindsAPM::Inst::FaradayConnection)
+
+  SW_APM_INSTR_ADAPTERS = [] # ["Faraday::Adapter::NetHttp", "Faraday::Adapter::Excon", "Faraday::Adapter::Typhoeus"]
+
+  SW_APM_INSTR_ADAPTERS << "Faraday::Adapter::Typhoeus" if defined? Faraday::Adapter::Typhoeus
+  SW_APM_INSTR_ADAPTERS << "Faraday::Adapter::NetHttp" if defined? Faraday::Adapter::NetHttp
+  SW_APM_INSTR_ADAPTERS << "Faraday::Adapter::Excon" if defined? Faraday::Adapter::Excon
+  SW_APM_INSTR_ADAPTERS << "Faraday::Adapter::HTTPClient" if defined? Faraday::Adapter::HTTPClient
+end

data/lib/solarwinds_apm/inst/graphql.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+#++
+#
+
+##
+# Tracing for the graphql gem
+#
+# This instrumentation is autoloaded when a class inherits GraphQL::Schema
+# no need to call `tracer` or `use`
+
+
+if defined?(GraphQL::Tracing) && !(SolarWindsAPM::Config[:graphql][:enabled] == false)
+  module GraphQL
+    module Tracing
+
+      class SolarWindsAPMTracing < GraphQL::Tracing::PlatformTracing
+        # These GraphQL events will show up as 'graphql.prep' spans
+        PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
+        EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
+
+        self.platform_keys = {
+          'lex' => 'lex',
+          'parse' => 'parse',
+          'validate' => 'validate',
+          'analyze_query' => 'analyze_query',
+          'analyze_multiplex' => 'analyze_multiplex',
+          'execute_multiplex' => 'execute_multiplex',
+          'execute_query' => 'execute_query',
+          'execute_query_lazy' => 'execute_query_lazy'
+        }
+
+        def platform_trace(platform_key, _key, data)
+          return yield if gql_config[:enabled] == false
+
+          layer = span_name(platform_key)
+          kvs = metadata(data, layer)
+          kvs[:Key] = platform_key if (PREP_KEYS + EXEC_KEYS).include?(platform_key)
+
+          transaction_name(kvs[:InboundQuery]) if kvs[:InboundQuery] && layer == 'graphql.execute'
+
+          ::SolarWindsAPM::SDK.trace(layer, kvs: kvs) do
+            kvs.clear # we don't have to send them twice
+            yield
+          end
+        end
+
+        def platform_field_key(type, field)
+          "graphql.#{type.graphql_name}.#{field.name}"
+        end
+
+        def platform_authorized_key(type)
+          "graphql.#{type.graphql_name}.authorized"
+        end
+
+        def platform_resolve_type_key(type)
+          "graphql.#{type.graphql_name}.resolve_type"
+        end
+
+        private
+
+        def gql_config
+          ::SolarWindsAPM::Config[:graphql] ||= {}
+        end
+
+        def transaction_name(query)
+          return if gql_config[:transaction_name] == false ||
+            ::SolarWindsAPM::SDK.get_transaction_name
+
+          split_query = query.strip.split(/\W+/, 3)
+          split_query[0] = 'query' if split_query[0].empty?
+          name = "graphql.#{split_query[0..1].join('.')}"
+
+          ::SolarWindsAPM::SDK.set_transaction_name(name)
+        end
+
+        def multiplex_transaction_name(names)
+          return if gql_config[:transaction_name] == false ||
+            ::SolarWindsAPM::SDK.get_transaction_name
+
+          name = "graphql.multiplex.#{names.join('.')}"
+          name = "#{name[0..251]}..." if name.length > 254
+
+          ::SolarWindsAPM::SDK.set_transaction_name(name)
+        end
+
+        def span_name(key)
+          return 'graphql.prep' if PREP_KEYS.include?(key)
+          return 'graphql.execute' if EXEC_KEYS.include?(key)
+
+          key[/^graphql\./] ? key : "graphql.#{key}"
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def metadata(data, layer)
+          kvs = data.keys.map do |key|
+            case key
+            when :context
+              graphql_context(data[:context], layer)
+            when :query
+              graphql_query(data[:query])
+            when :query_string
+              graphql_query_string(data[:query_string])
+            when :multiplex
+              graphql_multiplex(data[:multiplex])
+            else
+              [key, data[key]] unless key == :path # we get the path from context
+            end
+          end
+
+          kvs.compact.flatten.each_slice(2).to_h.merge(Spec: 'graphql')
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+        def graphql_context(context, layer)
+          context.errors && context.errors.each do |err|
+            SolarWindsAPM::API.log_exception(layer, err)
+          end
+
+          [[:Path, context.path.join('.')]]
+        end
+
+        def graphql_query(query)
+          return [] unless query
+
+          query_string = query.query_string
+          query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+          query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+          [[:InboundQuery, query_string],
+           [:Operation, query.selected_operation_name]]
+        end
+
+        def graphql_query_string(query_string)
+          query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+          query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+          [:InboundQuery, query_string]
+        end
+
+        def graphql_multiplex(data)
+          names = data.queries.map(&:operations).map(&:keys).flatten.compact
+          multiplex_transaction_name(names) if names.size > 1
+
+          [:Operations, names.join(', ')]
+        end
+
+        def sanitize(query)
+          return unless query
+
+          # remove arguments
+          query.gsub(/"[^"]*"/, '"?"')                 # strings
+               .gsub(/-?[0-9]*\.?[0-9]+e?[0-9]*/, '?') # ints + floats
+               .gsub(/\[[^\]]*\]/, '[?]')              # arrays
+        end
+
+        def remove_comments(query)
+          return unless query
+
+          query.gsub(/#[^\n\r]*/, '')
+        end
+      end
+    end
+  end
+
+  module SolarWindsAPM
+    module GraphQLSchemaPrepend
+
+      # Graphql doesn't check if a plugin is added twice
+      # we would get double traces
+      def use(plugin, **options)
+        super unless self.plugins.find { |pl| pl[0].to_s == plugin.to_s }
+
+        self.plugins
+      end
+
+      def inherited(subclass)
+        subclass.use(GraphQL::Tracing::SolarWindsAPMTracing)
+        super
+      end
+    end
+
+    module GraphQLErrorPrepend
+      def initialize(*args)
+        super
+        bt = SolarWindsAPM::API.backtrace(1)
+        set_backtrace(bt) unless self.backtrace
+      end
+    end
+  end
+
+
+  if Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.8.0')
+    SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting GraphQL' if SolarWindsAPM::Config[:verbose]
+    if defined?(GraphQL::Schema)
+      GraphQL::Schema.singleton_class.prepend(SolarWindsAPM::GraphQLSchemaPrepend)
+    end
+
+    if defined?(GraphQL::Error)
+      GraphQL::Error.prepend(SolarWindsAPM::GraphQLErrorPrepend)
+    end
+  end
+end

data/lib/solarwinds_apm/inst/grpc_client.rb

@@ -0,0 +1,147 @@
+# Copyright (c) 2018 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module GRPC
+
+    module ActiveCall
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      if defined? ::GRPC
+        StatusCodes = {}
+        ::GRPC::Core::StatusCodes.constants.each { |code| StatusCodes[::GRPC::Core::StatusCodes.const_get(code)] = code }
+      end
+
+      def self.included(klass)
+        SolarWindsAPM::Util.method_alias(klass, :request_response, ::GRPC::ActiveCall)
+        SolarWindsAPM::Util.method_alias(klass, :client_streamer, ::GRPC::ActiveCall)
+        SolarWindsAPM::Util.method_alias(klass, :server_streamer, ::GRPC::ActiveCall)
+        SolarWindsAPM::Util.method_alias(klass, :bidi_streamer, ::GRPC::ActiveCall)
+      end
+
+      def grpc_tags(method_type, method)
+        tags = { 'Spec' => 'rsc',
+                 'RemoteURL' => "grpc://#{peer}#{method}",
+                 'GRPCMethodType' => method_type,
+                 'IsService' => 'True'
+        }
+        tags
+      end
+
+      def request_response_with_sw_apm(req, metadata: {})
+        unary_response(req, type: 'UNARY', metadata: metadata, without: :request_response_without_sw_apm)
+      end
+
+      def client_streamer_with_sw_apm(req, metadata: {})
+        unary_response(req, type: 'CLIENT_STREAMING', metadata: metadata, without: :client_streamer_without_sw_apm)
+      end
+
+      def server_streamer_with_sw_apm(req, metadata: {}, &blk)
+        @tags = grpc_tags('SERVER_STREAMING', metadata['method'] || metadata_to_send['method'])
+        SolarWindsAPM::API.log_entry('grpc-client', @tags)
+        add_tracecontext_headers(metadata)
+
+        patch_receive_and_check_status # need to patch this so that log_exit can be called after the enum is consumed
+
+        response = server_streamer_without_sw_apm(req, metadata: metadata)
+        block_given? ? response.each { |r| yield r } : response
+      rescue => e
+        # this check is needed because the exception may have been logged in patch_receive_and_check_status
+        unless e.instance_variable_get(:@exn_logged)
+          SolarWindsAPM::API.log_exception('grpc-client', e)
+          SolarWindsAPM::API.log_exit('grpc-client', exit_tags(@tags))
+        end
+        raise e
+      end
+
+      def bidi_streamer_with_sw_apm(req, metadata: {}, &blk)
+        @tags = grpc_tags('BIDI_STREAMING', metadata['method'] || metadata_to_send['method'])
+        SolarWindsAPM::API.log_entry('grpc-client', @tags)
+        add_tracecontext_headers(metadata)
+
+        patch_set_input_stream_done
+
+        response = bidi_streamer_without_sw_apm(req, metadata: metadata)
+        block_given? ? response.each { |r| yield r } : response
+      rescue => e
+        unless e.instance_variable_get(:@exn_logged)
+          SolarWindsAPM::API.log_exception('grpc-client', e)
+          SolarWindsAPM::API.log_exit('grpc-client', exit_tags(@tags))
+        end
+        raise e
+      end
+
+      private
+
+      def unary_response(req, type:, metadata:, without:)
+        tags = grpc_tags(type, metadata['method'] || metadata_to_send['method'])
+        SolarWindsAPM::SDK.trace('grpc-client', kvs: tags) do
+          add_tracecontext_headers(metadata)
+          begin
+            send(without, req, metadata: metadata)
+          ensure
+            exit_tags(tags)
+          end
+        end
+      end
+
+      def patch_receive_and_check_status
+        def self.receive_and_check_status # need to patch this so that log_exit can be called after the enum is consumed
+          super
+        rescue => e
+          SolarWindsAPM::API.log_exception('grpc-client', e)
+          raise e
+        ensure
+          SolarWindsAPM::API.log_exit('grpc-client', exit_tags(@tags))
+        end
+      end
+
+      def patch_set_input_stream_done
+        # need to patch this instance method so that log_exit can be called after the enum is consumed
+        def self.set_input_stream_done
+          return if status.nil?
+          if status.code > 0
+            SolarWindsAPM::API.log_exception('grpc-client', $!)
+          end
+          SolarWindsAPM::API.log_exit('grpc-client', exit_tags(@tags))
+          super
+        end
+      end
+
+      def exit_tags(tags)
+        # we need to translate the status.code, it is not the status.details we want, they are not matching 1:1
+        tags['GRPCStatus'] ||= @call.status ? StatusCodes[@call.status.code].to_s : 'UNKNOWN'
+        tags['Backtrace'] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:grpc_client][:collect_backtraces]
+        tags
+      end
+    end
+
+  end
+end
+
+if defined?(GRPC) && SolarWindsAPM::Config[:grpc_client][:enabled]
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting GRPC' if SolarWindsAPM::Config[:verbose]
+
+  # Client side is instrumented in ActiveCall and ClientStub
+  SolarWindsAPM::Util.send_include(GRPC::ActiveCall, SolarWindsAPM::GRPC::ActiveCall)
+
+  GRPC_ClientStub_ops = [:request_response, :client_streamer, :server_streamer, :bidi_streamer]
+  module GRPC
+    class ClientStub
+      GRPC_ClientStub_ops.reject { |m| !method_defined?(m) }.each do |m|
+        define_method("#{m}_with_sw_apm") do |method, req, marshal, unmarshal, deadline: nil,
+          return_op: false, parent: nil,
+          credentials: nil, metadata: {}, &blk|
+
+          metadata['method'] = method
+          return send("#{m}_without_sw_apm", method, req, marshal, unmarshal, deadline: deadline,
+                      return_op: return_op, parent: parent,
+                      credentials: credentials, metadata: metadata, &blk)
+        end
+
+        SolarWindsAPM::Util.method_alias(GRPC::ClientStub, m)
+      end
+
+    end
+  end
+end