elastic-apm 3.5.0 → 3.6.0

data/docs/upgrading.asciidoc

@@ -0,0 +1,45 @@
+[[upgrading]]
+== Upgrading
+Upgrades between minor versions of the agent, like from 2.1 to 2.2 are always backwards compatible.
+Upgrades that involve a major version bump often come with some backwards incompatible changes.
+
+Before upgrading the agent, be sure to review the:
+
+* <<release-notes,Agent release notes>>
+* {apm-overview-ref-v}/agent-server-compatibility.html[Agent and Server compatibility chart]
+
+[float]
+[[end-of-life-dates]]
+=== End of life dates
+
+We love all our products, but sometimes we must say goodbye to a release so that we can continue moving
+forward on future development and innovation.
+Our https://www.elastic.co/support/eol[End of life policy] defines how long a given release is considered supported,
+as well as how long a release is considered still in active development or maintenance.
+The table below is a simplified description of this policy.
+
+[options="header"]
+|====
+|Agent version |EOL Date |Maintained until
+|3.5.x |2021-07-17 | 3.6
+|3.4.x |2021-07-10 | 3.5
+|3.3.x |2021-06-04 | 3.4
+|3.2.x |2021-05-19 | 3.3
+|3.1.x |2021-04-21 | 3.2
+|3.0.x |2021-04-08 | 3.1
+|2.12.x |2021-04-01 |4.0
+|2.11.x |2021-03-23 |2.12
+|2.10.x |2021-03-03 |2.11
+|2.9.x |2020-12-25 |2.10
+|2.8.x |2020-11-20 |2.9
+|2.7.x |2020-11-07 |2.8
+|2.6.x |2020-09-19 |2.7
+|2.5.x |2020-09-01 |2.6
+|2.4.x |2020-08-27 |2.5
+|2.3.x |2020-07-29 |2.4
+|2.2.x |2020-07-22 |2.3
+|2.1.x |2020-06-04 |2.2
+|2.0.x |2020-05-14 |2.1
+|1.1.x |2020-03-07 |3.0
+|1.0.x |2019-12-29 |1.1
+|====

data/lib/elastic_apm.rb

@@ -22,10 +22,12 @@ require 'elastic_apm/instrumenter'
 require 'elastic_apm/util'
 
 require 'elastic_apm/middleware'
+require 'elastic_apm/graphql'
 
 require 'elastic_apm/rails' if defined?(::Rails::Railtie)
 require 'elastic_apm/sinatra' if defined?(::Sinatra)
 require 'elastic_apm/grape' if defined?(::Grape)
+require 'elastic_apm/grpc' if defined?(::GRPC)
 
 # ElasticAPM
 module ElasticAPM
@@ -45,6 +47,16 @@ module ElasticAPM
       Agent.stop
     end
 
+    # Restarts the ElasticAPM Agent using the same config or a new
+    # one, if it is provided.
+    # Starts the agent if it is not running.
+    # Stops and starts the agent if it is running.
+    def restart(config = {})
+      config ||= agent&.config
+      stop if running?
+      start(config)
+    end
+
     # @return [Boolean] Whether there's an [Agent] running
     def running?
       Agent.running?

data/lib/elastic_apm/config.rb

@@ -70,7 +70,7 @@ module ElasticAPM
     option :transaction_max_spans,             type: :int,    default: 500
     option :transaction_sample_rate,           type: :float,  default: 1.0
     option :use_elastic_traceparent_header,    type: :bool,   default: true
-    option :use_experimental_sql_parser,       type: :bool,   default: false
+    option :use_legacy_sql_parser,             type: :bool,   default: false
     option :verify_server_cert,                type: :bool,   default: true
 
     # rubocop:enable Metrics/LineLength, Layout/ExtraSpacing
@@ -119,6 +119,7 @@ module ElasticAPM
         net_http
         rake
         redis
+        resque
         sequel
         shoryuken
         sidekiq
@@ -221,6 +222,11 @@ module ElasticAPM
       self.disable_instrumentations = value
     end
 
+    def use_experimental_sql_parser=(value)
+      warn '[DEPRECATED] The new SQL parser is now the default. To use the old one, '
+        'use use_legacy_sql_parser and please report why you wish to do so.'
+    end
+
     private
 
     def load_config_file

data/lib/elastic_apm/graphql.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module GraphQL
+    TYPE = 'app'
+    SUBTYPE = 'graphql'
+
+    PREFIX = 'GraphQL: '
+    UNNAMED = '[unnamed]'
+    MULTIPLE_QUERIES = '[multiple-queries]'
+    CONCATENATOR = '+'
+    MAX_NUMBER_OF_QUERIES_FOR_NAME = 5
+
+    KEYS_TO_NAME = {
+      'lex' => 'graphql.lex',
+      'parse' => 'graphql.parse',
+      'validate' => 'graphql.validate',
+      'analyze_multiplex' => 'graphql.analyze_multiplex',
+      'analyze_query' => 'graphql.analyze_query',
+      'execute_multiplex' => 'graphql.execute_multiplex',
+      'execute_query' => 'graphql.execute_query',
+      'execute_query_lazy' => 'graphql.execute_query_lazy',
+      'authorized_lazy' => 'graphql.authorized_lazy',
+      'resolve_type' => 'graphql.resolve_type',
+      'resolve_type_lazy' => 'graphql.resolve_type_lazy'
+
+      # These are available but deliberately left out as they are mostly noise.
+      # "execute_field" => "graphql.execute_field",
+      # "execute_field_lazy" => "graphql.execute_field_lazy",
+      # "authorized" => "graphql.authorized",
+    }.freeze
+
+    def self.trace(key, data)
+      return yield unless KEYS_TO_NAME.key?(key)
+      return yield unless (transaction = ElasticAPM.current_transaction)
+
+      if key == 'execute_query'
+        transaction.name =
+          "#{PREFIX}#{query_name(data[:query])}"
+      end
+
+      results =
+        ElasticAPM.with_span(
+          KEYS_TO_NAME.fetch(key, key),
+          TYPE, subtype: SUBTYPE, action: key
+        ) { yield }
+
+      if key == 'execute_multiplex'
+        transaction.name = "#{PREFIX}#{concat_names(results)}"
+      end
+
+      results
+    end
+
+    class << self
+      private
+
+      def query_name(query)
+        query.operation_name || UNNAMED
+      end
+
+      def concat_names(results)
+        if results.length > MAX_NUMBER_OF_QUERIES_FOR_NAME
+          return MULTIPLE_QUERIES
+        end
+
+        results.map do |result|
+          query_name(result.query)
+        end.join(CONCATENATOR)
+      end
+    end
+  end
+end

data/lib/elastic_apm/grpc.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class GRPC
+    # @api private
+    class ClientInterceptor < ::GRPC::ClientInterceptor
+      TYPE = 'external'
+      SUBTYPE = 'grpc'
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def request_response(request:, call:, method:, metadata:)
+        return yield unless (transaction = ElasticAPM.current_transaction)
+        if (trace_context = transaction.trace_context)
+          trace_context.apply_headers { |k, v| metadata[k.downcase] = v }
+        end
+
+        ElasticAPM.with_span(
+          method, TYPE,
+          subtype: SUBTYPE,
+          context: span_context(call)
+        ) do
+          yield
+        end
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      private
+
+      def span_context(call)
+        peer = call.instance_variable_get(:@wrapped)&.peer
+        return unless peer
+
+        split_peer = URI.split(peer)
+        destination = ElasticAPM::Span::Context::Destination.new(
+          type: TYPE,
+          name: SUBTYPE,
+          resource: peer,
+          address: split_peer[0],
+          port: split_peer[6]
+        )
+        ElasticAPM::Span::Context.new(destination: destination)
+      end
+    end
+
+    # @api private
+    class ServerInterceptor < ::GRPC::ClientInterceptor
+      TYPE = 'request'
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def request_response(request:, call:, method:)
+        transaction = start_transaction(call)
+        yield
+        transaction.done 'success'
+      rescue ::Exception => e
+        ElasticAPM.report(e, handled: false)
+        transaction.done 'error'
+        raise
+      ensure
+        ElasticAPM.end_transaction
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      private
+
+      def start_transaction(call)
+        ElasticAPM.start_transaction(
+          'grpc',
+          'request',
+          trace_context: trace_context(call)
+        )
+      end
+
+      def trace_context(call)
+        TraceContext.parse(metadata: call.metadata)
+      rescue TraceContext::InvalidTraceparentHeader
+        warn "Couldn't parse invalid trace context header: #{header.inspect}"
+        nil
+      end
+    end
+  end
+end

data/lib/elastic_apm/resque.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # Defines a before_first_fork hook for starting the ElasticAPM agent
+  # with Resque.
+  module Resque
+    ::Resque.before_first_fork do
+      ::Resque.logger.debug('Starting ElasticAPM agent')
+      ElasticAPM.start
+    end
+  end
+end

data/lib/elastic_apm/span/context/destination.rb

@@ -5,21 +5,37 @@ module ElasticAPM
     class Context
       # @api private
       class Destination
-        def initialize(name: nil, resource: nil, type: nil)
+        def initialize(
+          name: nil,
+          resource: nil,
+          type: nil,
+          address: nil,
+          port: nil
+        )
           @name = name
           @resource = resource
           @type = type
+          @address = address
+          @port = port
         end
 
-        attr_reader :name, :resource, :type
+        attr_reader(
+          :name,
+          :resource,
+          :type,
+          :address,
+          :port
+        )
 
-        def self.from_uri(uri_or_str, type: 'external')
+        def self.from_uri(uri_or_str, type: 'external', port: nil)
           uri = normalize(uri_or_str)
 
           new(
             name: only_scheme_and_host(uri),
             resource: "#{uri.host}:#{uri.port}",
-            type: type
+            type: type,
+            address: uri.hostname,
+            port: port || uri.port
           )
         end
 

data/lib/elastic_apm/spies/resque.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Spies
+    # @api private
+    class ResqueSpy
+      TYPE = 'Resque'
+
+      def install
+        install_perform_spy
+        install_after_fork_hook
+      end
+
+      def install_after_fork_hook
+        ::Resque.after_fork do
+          ElasticAPM.restart
+        end
+      end
+
+      def install_perform_spy
+        ::Resque::Job.class_eval do
+          alias :perform_without_elastic_apm :perform
+
+          def perform
+            name = @payload && @payload['class']&.name
+            transaction = ElasticAPM.start_transaction(name, TYPE)
+            perform_without_elastic_apm
+            transaction.done 'success'
+          rescue ::Exception => e
+            ElasticAPM.report(e, handled: false)
+            transaction.done 'error'
+            raise
+          ensure
+            ElasticAPM.end_transaction
+          end
+        end
+      end
+    end
+
+    register 'Resque', 'resque', ResqueSpy.new
+  end
+end

data/lib/elastic_apm/sql.rb

@@ -7,12 +7,12 @@ module ElasticAPM
     # both implementations ~mikker
     def self.summarizer
       @summarizer ||=
-        if ElasticAPM.agent&.config&.use_experimental_sql_parser
-          require 'elastic_apm/sql/signature'
-          Sql::Signature::Summarizer.new
-        else
+        if ElasticAPM.agent&.config&.use_legacy_sql_parser
           require 'elastic_apm/sql_summarizer'
           SqlSummarizer.new
+        else
+          require 'elastic_apm/sql/signature'
+          Sql::Signature::Summarizer.new
         end
     end
   end

data/lib/elastic_apm/stacktrace_builder.rb

@@ -12,7 +12,12 @@ module ElasticAPM
     RUBY_VERS_REGEX = %r{ruby(/gems)?[-/](\d+\.)+\d}.freeze
     JRUBY_ORG_REGEX = %r{org/jruby}.freeze
 
-    GEMS_PATH = defined?(Bundler) ? Bundler.bundle_path.to_s : Gem.dir
+    GEMS_PATH =
+      if defined?(Bundler) && Bundler.default_bundle_dir
+        Bundler.bundle_path.to_s
+      else
+        Gem.dir
+      end
 
     def initialize(config)
       @config = config

data/lib/elastic_apm/trace_context.rb

@@ -25,15 +25,30 @@ module ElasticAPM
       :version, :trace_id, :id, :parent_id, :ensure_parent_id, :recorded?
 
     class << self
-      def parse(legacy_header = nil, env: nil)
-        if !legacy_header && !env
-          raise ArgumentError, 'TraceContext expects either env: or single ' \
-            'argument header string'
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def parse(legacy_header = nil, env: nil, metadata: nil)
+        unless legacy_header || env || metadata
+          raise ArgumentError, 'TraceContext expects env:, metadata: ' \
+            'or single argument header string'
         end
 
-        return legacy_parse_from_header(legacy_header) if legacy_header
+        if legacy_header
+          legacy_parse_from_header(legacy_header)
+        elsif env
+          trace_context_from_env(env)
+        elsif metadata
+          trace_context_from_metadata(metadata)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      private
 
-        return unless (header = get_traceparent_header(env))
+      def trace_context_from_env(env)
+        return unless (
+          header =
+            env['HTTP_ELASTIC_APM_TRACEPARENT'] || env['HTTP_TRACEPARENT']
+        )
 
         parent = TraceContext::Traceparent.parse(header)
 
@@ -45,16 +60,24 @@ module ElasticAPM
         new(traceparent: parent, tracestate: state)
       end
 
-      private
+      def trace_context_from_metadata(metadata)
+        return unless (header = metadata['elastic-apm-traceparent'] ||
+          metadata['traceparent'])
+
+        parent = TraceContext::Traceparent.parse(header)
+
+        state =
+          if (header = metadata['tracestate'])
+            TraceContext::Tracestate.parse(header)
+          end
+
+        new(traceparent: parent, tracestate: state)
+      end
 
       def legacy_parse_from_header(header)
         parent = Traceparent.parse(header)
         new(traceparent: parent)
       end
-
-      def get_traceparent_header(env)
-        env['HTTP_ELASTIC_APM_TRACEPARENT'] || env['HTTP_TRACEPARENT']
-      end
     end
 
     def child