appoptics_apm-zearn 4.13.1

data/lib/appoptics_apm/inst/excon.rb

@@ -0,0 +1,125 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module ExconConnection
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :request, ::Excon::Connection)
+        AppOpticsAPM::Util.method_alias(klass, :requests, ::Excon::Connection)
+      end
+
+      private
+
+      def appoptics_collect(params)
+        kvs = {}
+        kvs[:Spec] = 'rsc'
+        kvs[:IsService] = 1
+
+        # Conditionally log query args
+        if AppOpticsAPM::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 << AppOpticsAPM::Util.upcase(p[:method])
+          end
+          kvs[:HTTPMethods] = methods.join(',')[0..1024]
+          kvs[:Pipeline] = true
+        else
+          kvs[:HTTPMethod] = AppOpticsAPM::Util.upcase(params[:method])
+        end
+        kvs
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error capturing excon KVs: #{e.message}"
+        AppOpticsAPM.logger.debug e.backtrace.join('\n') if AppOpticsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      public
+
+      def requests_with_appoptics(pipeline_params)
+        responses = nil
+        kvs = appoptics_collect(pipeline_params)
+        AppOpticsAPM::API.trace(:excon, kvs) do
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:excon][:collect_backtraces]
+          responses = requests_without_appoptics(pipeline_params)
+          kvs[:HTTPStatuses] = responses.map { |r| r.status }.join(',')
+        end
+        responses
+      end
+
+      def request_with_appoptics(params={}, &block)
+        # Avoid cross host tracing for blacklisted domains
+        blacklisted = AppOpticsAPM::API.blacklisted?(@data[:hostname] || @data[:host])
+
+        # 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 !AppOpticsAPM.tracing? || params[:pipeline]
+          @data[:headers]['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid && !blacklisted
+          return request_without_appoptics(params, &block)
+        end
+
+        begin
+          response_context = nil
+
+          kvs = appoptics_collect(params)
+          kvs[:Blacklisted] = true if blacklisted
+
+          AppOpticsAPM::API.log_entry(:excon, kvs)
+          kvs.clear
+
+          req_context = AppOpticsAPM::Context.toString
+          @data[:headers]['X-Trace'] = req_context unless blacklisted
+
+          # The core excon call
+          response = request_without_appoptics(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)
+            response_context = response.headers['X-Trace']
+            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
+
+            if response_context && !blacklisted
+              AppOpticsAPM::XTrace.continue_service_context(req_context, response_context)
+            end
+          end
+
+          response
+        rescue => e
+          AppOpticsAPM::API.log_exception(:excon, e)
+          raise e
+        ensure
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:excon][:collect_backtraces]
+          AppOpticsAPM::API.log_exit(:excon, kvs) unless params[:pipeline]
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:excon][:enabled] && defined?(Excon)
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting excon' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(Excon::Connection, AppOpticsAPM::Inst::ExconConnection)
+end

data/lib/appoptics_apm/inst/faraday.rb

@@ -0,0 +1,106 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module FaradayConnection
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :run_request, ::Faraday::Connection)
+      end
+
+      def run_request_with_appoptics(method, url, body, headers, &block)
+        blacklisted = url_blacklisted?
+        remote_call = remote_call?
+
+        unless AppOpticsAPM.tracing?
+          if remote_call && !blacklisted
+            xtrace = AppOpticsAPM::Context.toString
+            @headers['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace)
+          end
+          return run_request_without_appoptics(method, url, body, headers, &block)
+        end
+
+        begin
+          AppOpticsAPM::API.log_entry(:faraday)
+          xtrace = nil
+          if remote_call && !blacklisted
+            xtrace = AppOpticsAPM::Context.toString
+            @headers['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace)
+          end
+
+          result = run_request_without_appoptics(method, url, body, headers, &block)
+
+          # Re-attach edge unless it's blacklisted
+          # or if we don't have a valid X-Trace header
+          if remote_call && !blacklisted
+            xtrace_new = result.headers['X-Trace']
+            AppOpticsAPM::XTrace.continue_service_context(xtrace, xtrace_new)
+          end
+          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] = AppOpticsAPM::API.backtrace if AppOpticsAPM::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))
+            unless blacklisted
+              xtrace_new = result.headers['X-Trace']
+              AppOpticsAPM::XTrace.continue_service_context(xtrace, xtrace_new)
+            end
+          end
+
+          result
+        rescue => e
+          AppOpticsAPM::API.log_exception(:faraday, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:faraday, kvs)
+        end
+      end
+
+      private
+
+      def url_blacklisted?
+        url = @url_prefix ? @url_prefix.to_s : @host
+        AppOpticsAPM::API.blacklisted?(url)
+      end
+
+      # 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) & APPOPTICS_INSTR_ADAPTERS).count == 0
+        else
+          ((@builder.handlers.map(&:name) << @builder.adapter.name) & APPOPTICS_INSTR_ADAPTERS).count == 0
+        end
+      end
+
+      def rsc_kvs(_url, method, result)
+        kvs = { :Spec => 'rsc',
+                :IsService => 1,
+                :HTTPMethod => method.upcase,
+                :HTTPStatus => result.status, }
+        kvs[:Blacklisted] = true if url_blacklisted?
+        kvs[:RemoteURL] = result.env.to_hash[:url].to_s
+        kvs[:RemoteURL].split('?').first unless AppOpticsAPM::Config[:faraday][:log_args]
+
+        kvs
+      end
+    end
+  end
+end
+
+if defined?(Faraday) && AppOpticsAPM::Config[:faraday][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting faraday' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(Faraday::Connection, AppOpticsAPM::Inst::FaradayConnection)
+  APPOPTICS_INSTR_ADAPTERS = ["Faraday::Adapter::NetHttp", "Faraday::Adapter::Excon", "Faraday::Adapter::Typhoeus"]
+  APPOPTICS_INSTR_ADAPTERS << "Faraday::Adapter::HTTPClient" if defined?Faraday::Adapter::HTTPClient
+end

data/lib/appoptics_apm/inst/graphql.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+#++
+
+# initial version of this instrumentation:
+# https://github.com/librato/api/blob/master/graph/tracing/appoptics.rb
+#
+
+# TODO: make sure this stays up to date with
+# ____  what is in the graphql gem and vice-versa
+
+
+if defined?(GraphQL::Tracing) && !(AppOpticsAPM::Config[:graphql][:enabled] == false)
+  module GraphQL
+    module Tracing
+      # AppOpticsTracing in the graphql gem may be a different version than the
+      # one defined here, we want to use the newer one
+      redefine = true
+      this_version = Gem::Version.new('1.0.0')
+
+      if defined?(GraphQL::Tracing::AppOpticsTracing)
+        if this_version > GraphQL::Tracing::AppOpticsTracing.version
+          send(:remove_const, :AppOpticsTracing)
+        else
+          redefine = false
+        end
+      end
+
+      if redefine
+        #-----------------------------------------------------------------------------#
+        #----- this class is duplicated in the graphql gem ---------------------------#
+        #-----------------------------------------------------------------------------#
+        class AppOpticsTracing < 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
+
+          # During auto-instrumentation this version of AppOpticsTracing is compared
+          # with the version provided in the graphql gem, so that the newer
+          # version of the class can be used
+
+          def self.version
+            Gem::Version.new('1.0.0')
+          end
+
+          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 !defined?(AppOpticsAPM) || 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'
+
+            ::AppOpticsAPM::SDK.trace(layer, kvs) do
+              kvs.clear # we don't have to send them twice
+              yield
+            end
+          end
+
+          def platform_field_key(type, field)
+            "graphql.#{type.name}.#{field.name}"
+          end
+
+          private
+
+          def gql_config
+            ::AppOpticsAPM::Config[:graphql] ||= {}
+          end
+
+          def transaction_name(query)
+            return if gql_config[:transaction_name] == false ||
+              ::AppOpticsAPM::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('.')}"
+
+            ::AppOpticsAPM::SDK.set_transaction_name(name)
+          end
+
+          def multiplex_transaction_name(names)
+            return if gql_config[:transaction_name] == false ||
+              ::AppOpticsAPM::SDK.get_transaction_name
+
+            name = "graphql.multiplex.#{names.join('.')}"
+            name = "#{name[0..251]}..." if name.length > 254
+
+            ::AppOpticsAPM::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)
+            data.keys.map do |key|
+              case key
+              when :context
+                graphql_context(data[key], layer)
+              when :query
+                graphql_query(data[key])
+              when :query_string
+                graphql_query_string(data[key])
+              when :multiplex
+                graphql_multiplex(data[key])
+              else
+                [key, data[key]]
+              end
+            end.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|
+              AppOpticsAPM::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
+  end
+
+  module AppOpticsAPM
+    module GraphQLSchemaPrepend
+      def use(plugin, **options)
+        # super unless GraphQL::Schema.plugins.find { |pl| pl[0].to_s == plugin.to_s }
+        super unless self.plugins.find { |pl| pl[0].to_s == plugin.to_s }
+
+        self.plugins
+      end
+
+      def inherited(subclass)
+        subclass.use(GraphQL::Tracing::AppOpticsTracing)
+        super
+      end
+    end
+
+    # rubocop:disable Style/RedundantSelf
+    module GraphQLErrorPrepend
+      def initialize(*args)
+        super
+        bt = AppOpticsAPM::API.backtrace(1)
+        set_backtrace(bt) unless self.backtrace
+      end
+    end
+    # rubocop:enable Style/RedundantSelf
+
+    # a different way of autoinstrumenting for graphql 1.7.4 - < 1.8.0
+    module GraphQLSchemaPrepend17
+      def initialize
+        super
+        unless tracers.find { |tr| tr.is_a? GraphQL::Tracing::AppOpticsTracing }
+          tracer = GraphQL::Tracing::AppOpticsTracing.new
+          tracers.push(tracer)
+          instrumenters[:field] << tracer
+        end
+      end
+    end
+  end
+
+  if Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.8.0')
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting GraphQL' if AppOpticsAPM::Config[:verbose]
+    if defined?(GraphQL::Schema)
+      GraphQL::Schema.singleton_class.prepend(AppOpticsAPM::GraphQLSchemaPrepend)
+    end
+
+    # rubocop:disable Style/IfUnlessModifier
+    if defined?(GraphQL::Error)
+      GraphQL::Error.prepend(AppOpticsAPM::GraphQLErrorPrepend)
+    end
+    # rubocop:enable Style/IfUnlessModifier
+  elsif Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.7.4')
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting GraphQL' if AppOpticsAPM::Config[:verbose]
+    if defined?(GraphQL::Schema)
+      GraphQL::Schema.prepend(AppOpticsAPM::GraphQLSchemaPrepend17)
+    end
+  end
+end

data/lib/appoptics_apm/inst/grpc_client.rb

@@ -0,0 +1,159 @@
+# Copyright (c) 2018 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module GRPC
+
+    module ActiveCall
+      if defined? ::GRPC
+        StatusCodes = {}
+        ::GRPC::Core::StatusCodes.constants.each { |code| StatusCodes[::GRPC::Core::StatusCodes.const_get(code)] = code }
+      end
+
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :request_response, ::GRPC::ActiveCall)
+        AppOpticsAPM::Util.method_alias(klass, :client_streamer, ::GRPC::ActiveCall)
+        AppOpticsAPM::Util.method_alias(klass, :server_streamer, ::GRPC::ActiveCall)
+        AppOpticsAPM::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_appoptics(req, metadata: {})
+        unary_response(req, type: 'UNARY', metadata: metadata, without: :request_response_without_appoptics)
+      end
+
+      def client_streamer_with_appoptics(req, metadata: {})
+        unary_response(req, type: 'CLIENT_STREAMING', metadata: metadata, without: :client_streamer_without_appoptics)
+      end
+
+      def server_streamer_with_appoptics(req, metadata: {}, &blk)
+        @tags = grpc_tags('SERVER_STREAMING', metadata[:method] || metadata_to_send[:method])
+        AppOpticsAPM::API.log_entry('grpc-client', @tags)
+        metadata['x-trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+
+        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_appoptics(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)
+          context_from_incoming
+          AppOpticsAPM::API.log_exception('grpc-client', e)
+          AppOpticsAPM::API.log_exit('grpc-client', exit_tags(@tags))
+        end
+        raise e
+      end
+
+      def bidi_streamer_with_appoptics(req, metadata: {}, &blk)
+        @tags = grpc_tags('BIDI_STREAMING', metadata[:method] || metadata_to_send[:method])
+        AppOpticsAPM::API.log_entry('grpc-client', @tags)
+        metadata['x-trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+
+        patch_set_input_stream_done
+
+        response = bidi_streamer_without_appoptics(req, metadata: metadata)
+        block_given? ? response.each { |r| yield r } : response
+      rescue => e
+        unless e.instance_variable_get(:@exn_logged)
+          context_from_incoming
+          AppOpticsAPM::API.log_exception('grpc-client', e)
+          AppOpticsAPM::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])
+        AppOpticsAPM::SDK.trace('grpc-client', tags) do
+          metadata['x-trace'] = AppOpticsAPM::Context.toString  if AppOpticsAPM::Context.isValid
+          begin
+            send(without, req, metadata: metadata)
+          ensure
+            exit_tags(tags)
+            context_from_incoming
+          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
+          context_from_incoming
+        rescue => e
+          context_from_incoming
+          AppOpticsAPM::API.log_exception('grpc-client', e)
+          raise e
+        ensure
+          AppOpticsAPM::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?
+          context_from_incoming
+          if status.code > 0
+            AppOpticsAPM::API.log_exception('grpc-client', $!)
+          end
+          AppOpticsAPM::API.log_exit('grpc-client', exit_tags(@tags))
+          super
+        end
+      end
+
+      def context_from_incoming
+        if AppOpticsAPM::Context.isValid
+          xtrace ||= @call.trailing_metadata['x-trace'] if @call.trailing_metadata && @call.trailing_metadata['x-trace']
+          xtrace ||= @call.metadata['x-trace'] if @call.metadata && @call.metadata['x-trace']
+          AppOpticsAPM::Context.fromString(xtrace) if xtrace
+        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'] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grpc_client][:collect_backtraces]
+        tags
+      end
+    end
+
+  end
+end
+
+if defined?(GRPC) && AppOpticsAPM::Config[:grpc_client][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting GRPC' if AppOpticsAPM::Config[:verbose]
+
+  # Client side is instrumented in ActiveCall and ClientStub
+  AppOpticsAPM::Util.send_include(GRPC::ActiveCall, AppOpticsAPM::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_appoptics") do |method, req, marshal, unmarshal, deadline: nil,
+            return_op: false, parent: nil,
+            credentials: nil, metadata: {}, &blk|
+
+          metadata[:method] = method
+          return send("#{m}_without_appoptics", method, req, marshal, unmarshal, deadline: deadline,
+                      return_op: return_op, parent: parent,
+                      credentials: credentials, metadata: metadata, &blk)
+        end
+
+        AppOpticsAPM::Util.method_alias(GRPC::ClientStub, m)
+      end
+
+    end
+  end
+end