elastic-apm 2.1.2 → 2.2.0

data/lib/elastic_apm/agent.rb

@@ -49,12 +49,14 @@ module ElasticAPM
     def initialize(config)
       @config = config
 
-      @transport = Transport::Base.new(config)
-      @instrumenter = Instrumenter.new(config) { |event| enqueue event }
-
       @stacktrace_builder = StacktraceBuilder.new(config)
-      @context_builder = ContextBuilder.new(self)
+      @context_builder = ContextBuilder.new(config)
       @error_builder = ErrorBuilder.new(self)
+
+      @transport = Transport::Base.new(config)
+      @instrumenter = Instrumenter.new(
+        config, stacktrace_builder: stacktrace_builder
+      ) { |event| enqueue event }
     end
 
     attr_reader :config, :transport, :instrumenter,
@@ -106,13 +108,13 @@ module ElasticAPM
       name = nil,
       type = nil,
       context: nil,
-      traceparent: nil
+      trace_context: nil
     )
       instrumenter.start_transaction(
         name,
         type,
         context: context,
-        traceparent: traceparent
+        trace_context: trace_context
       )
     end
 
@@ -120,12 +122,19 @@ module ElasticAPM
       instrumenter.end_transaction(result)
     end
 
-    def start_span(name = nil, type = nil, backtrace: nil, context: nil)
+    def start_span(
+      name = nil,
+      type = nil,
+      backtrace: nil,
+      context: nil,
+      trace_context: nil
+    )
       instrumenter.start_span(
         name,
         type,
         backtrace: backtrace,
-        context: context
+        context: context,
+        trace_context: trace_context
       )
     end
 

data/lib/elastic_apm/config.rb

@@ -2,6 +2,7 @@
 
 require 'logger'
 require 'yaml'
+require 'erb'
 
 require 'elastic_apm/util/prefixed_logger'
 require 'elastic_apm/config/duration'
@@ -21,6 +22,9 @@ module ElasticAPM
       api_buffer_size: 256,
       api_request_size: '750kb',
       api_request_time: '10s',
+      capture_body: true,
+      capture_headers: true,
+      capture_env: true,
       current_user_email_method: :email,
       current_user_id_method: :id,
       current_user_username_method: :username,
@@ -57,6 +61,9 @@ module ElasticAPM
       'ELASTIC_APM_API_BUFFER_SIZE' => [:int, 'api_buffer_size'],
       'ELASTIC_APM_API_REQUEST_SIZE' => [:int, 'api_request_size'],
       'ELASTIC_APM_API_REQUEST_TIME' => 'api_request_time',
+      'ELASTIC_APM_CAPTURE_BODY' => [:bool, 'capture_body'],
+      'ELASTIC_APM_CAPTURE_HEADERS' => [:bool, 'capture_headers'],
+      'ELASTIC_APM_CAPTURE_ENV' => [:bool, 'capture_env'],
       'ELASTIC_APM_CUSTOM_KEY_FILTERS' => [:list, 'custom_key_filters'],
       'ELASTIC_APM_DEFAULT_TAGS' => [:dict, 'default_tags'],
       'ELASTIC_APM_DISABLED_SPIES' => [:list, 'disabled_spies'],
@@ -118,6 +125,9 @@ module ElasticAPM
     attr_accessor :api_buffer_size
     attr_accessor :api_request_size
     attr_accessor :api_request_time
+    attr_accessor :capture_body
+    attr_accessor :capture_headers
+    attr_accessor :capture_env
     attr_accessor :current_user_email_method
     attr_accessor :current_user_id_method
     attr_accessor :current_user_method
@@ -155,6 +165,9 @@ module ElasticAPM
     attr_accessor :view_paths
     attr_accessor :root_path
 
+    alias :capture_body? :capture_body
+    alias :capture_headers? :capture_headers
+    alias :capture_env? :capture_env
     alias :disable_send? :disable_send
     alias :http_compression? :http_compression
     alias :instrument? :instrument
@@ -229,6 +242,10 @@ module ElasticAPM
       @span_frames_min_duration_us = duration * 1_000_000
     end
 
+    def span_frames_min_duration?
+      span_frames_min_duration != 0
+    end
+
     DEPRECATED_OPTIONS = %i[
       compression_level=
       compression_minimum_size=
@@ -307,7 +324,7 @@ module ElasticAPM
 
     def set_from_config_file
       return unless File.exist?(config_file)
-      assign(YAML.load_file(config_file) || {})
+      assign(YAML.safe_load(ERB.new(File.read(config_file)).result) || {})
     rescue ConfigError => e
       alert_logger.warn format(
         'Failed to configure from config file: %s',

data/lib/elastic_apm/context.rb

@@ -12,9 +12,10 @@ module ElasticAPM
     attr_accessor :request, :response, :user
     attr_reader :custom, :tags
 
-    def initialize(custom: {}, tags: {})
+    def initialize(custom: {}, tags: {}, user: nil)
       @custom = custom
       @tags = tags
+      @user = user || User.new
     end
   end
 end

data/lib/elastic_apm/context/user.rb

@@ -4,20 +4,34 @@ module ElasticAPM
   class Context
     # @api private
     class User
-      def initialize(config, record)
+      def initialize(id: nil, email: nil, username: nil)
+        @id = id
+        @email = email
+        @username = username
+      end
+
+      def self.infer(config, record)
         return unless record
 
-        @id = safe_get(record, config.current_user_id_method)&.to_s
-        @email = safe_get(record, config.current_user_email_method)
-        @username = safe_get(record, config.current_user_username_method)
+        new(
+          id: safe_get(record, config.current_user_id_method)&.to_s,
+          email: safe_get(record, config.current_user_email_method),
+          username: safe_get(record, config.current_user_username_method)
+        )
       end
 
       attr_accessor :id, :email, :username
 
-      private
+      def empty?
+        !id && !email && !username
+      end
+
+      class << self
+        private
 
-      def safe_get(record, method_name)
-        record.respond_to?(method_name) ? record.send(method_name) : nil
+        def safe_get(record, method_name)
+          record.respond_to?(method_name) ? record.send(method_name) : nil
+        end
       end
     end
   end

data/lib/elastic_apm/context_builder.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 module ElasticAPM
-  # TODO: Move to txn.add_request ?
   # @api private
   class ContextBuilder
-    def initialize(_agent); end
+    def initialize(config)
+      @config = config
+    end
+
+    attr_reader :config
 
     def build(rack_env)
       context = Context.new
@@ -14,7 +17,7 @@ module ElasticAPM
 
     private
 
-    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def apply_to_request(context, rack_env)
       req = rails_req?(rack_env) ? rack_env : Rack::Request.new(rack_env)
 
@@ -25,12 +28,16 @@ module ElasticAPM
       request.http_version = build_http_version rack_env
       request.method = req.request_method
       request.url = Context::Request::Url.new(req)
-      request.headers, request.env = get_headers_and_env(rack_env)
-      request.body = get_body(req)
+
+      request.body = get_body(req) if config.capture_body?
+
+      headers, env = get_headers_and_env(rack_env)
+      request.headers = headers if config.capture_headers?
+      request.env = env if config.capture_env?
 
       context
     end
-    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def get_body(req)
       return req.POST if req.form_data?

data/lib/elastic_apm/instrumenter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'elastic_apm/trace_context'
 require 'elastic_apm/span'
 require 'elastic_apm/transaction'
 
@@ -7,16 +8,16 @@ module ElasticAPM
   # rubocop:disable Metrics/ClassLength
   # @api private
   class Instrumenter
-    include Logging
+    TRANSACTION_KEY = :__elastic_instrumenter_transaction_key
+    SPAN_KEY = :__elastic_instrumenter_spans_key
 
-    TRANSACTION_KEY = :__elastic_transaction_key
-    SPAN_KEY = :__elastic_span_key
+    include Logging
 
     # @api private
     class Current
       def initialize
         self.transaction = nil
-        self.span = nil
+        self.spans = []
       end
 
       def transaction
@@ -27,23 +28,25 @@ module ElasticAPM
         Thread.current[TRANSACTION_KEY] = transaction
       end
 
-      def span
-        Thread.current[SPAN_KEY]
+      def spans
+        Thread.current[SPAN_KEY] ||= []
       end
 
-      def span=(span)
-        Thread.current[SPAN_KEY] = span
+      def spans=(spans)
+        Thread.current[SPAN_KEY] ||= []
+        Thread.current[SPAN_KEY] = spans
       end
     end
 
-    def initialize(config, &enqueue)
+    def initialize(config, stacktrace_builder:, &enqueue)
       @config = config
+      @stacktrace_builder = stacktrace_builder
       @enqueue = enqueue
 
       @current = Current.new
     end
 
-    attr_reader :config, :enqueue
+    attr_reader :config, :stacktrace_builder, :enqueue
 
     def start
       debug 'Starting instrumenter'
@@ -53,7 +56,7 @@ module ElasticAPM
       debug 'Stopping instrumenter'
 
       self.current_transaction = nil
-      self.current_span = nil
+      current_spans.pop until current_spans.empty?
 
       @subscriber.unregister! if @subscriber
     end
@@ -78,7 +81,7 @@ module ElasticAPM
       name = nil,
       type = nil,
       context: nil,
-      traceparent: nil
+      trace_context: nil
     )
       return nil unless config.instrument?
 
@@ -87,14 +90,14 @@ module ElasticAPM
           "Transactions may not be nested.\nAlready inside #{transaction}"
       end
 
-      sampled = traceparent ? traceparent.recorded? : random_sample?
+      sampled = trace_context ? trace_context.recorded? : random_sample?
 
       transaction =
         Transaction.new(
           name,
           type,
           context: context,
-          traceparent: traceparent,
+          trace_context: trace_context,
           sampled: sampled
         )
 
@@ -118,16 +121,23 @@ module ElasticAPM
 
     # spans
 
-    def current_span
-      @current.span
+    def current_spans
+      @current.spans
     end
 
-    def current_span=(span)
-      @current.span = span
+    def current_span
+      current_spans.last
     end
 
     # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-    def start_span(name, type = nil, backtrace: nil, context: nil)
+    # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+    def start_span(
+      name,
+      type = nil,
+      backtrace: nil,
+      context: nil,
+      trace_context: nil
+    )
       return unless (transaction = current_transaction)
       return unless transaction.sampled?
 
@@ -138,32 +148,34 @@ module ElasticAPM
         return
       end
 
+      parent = current_span || transaction
+
       span = Span.new(
         name,
         type,
-        transaction: transaction,
-        parent: current_span || transaction,
-        context: context
+        transaction_id: transaction.id,
+        parent_id: parent.id,
+        context: context,
+        stacktrace_builder: stacktrace_builder,
+        trace_context: trace_context || parent.trace_context.child
       )
 
-      if backtrace && span_frames_min_duration?
+      if backtrace && config.span_frames_min_duration?
         span.original_backtrace = backtrace
       end
 
-      self.current_span = span
+      current_spans.push span
 
       span.start
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
     # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
     def end_span
-      return unless (span = current_span)
+      return unless (span = current_spans.pop)
 
       span.done
 
-      self.current_span =
-        span.parent&.is_a?(Span) && span.parent || nil
-
       enqueue.call span
 
       span
@@ -185,7 +197,7 @@ module ElasticAPM
 
     def set_user(user)
       return unless current_transaction
-      current_transaction.context.user = Context::User.new(config, user)
+      current_transaction.context.user = Context::User.infer(config, user)
     end
 
     def inspect
@@ -199,10 +211,6 @@ module ElasticAPM
     def random_sample?
       rand <= config.transaction_sample_rate
     end
-
-    def span_frames_min_duration?
-      config.span_frames_min_duration != 0
-    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/lib/elastic_apm/middleware.rb

@@ -1,8 +1,6 @@
 #
 # frozen_string_literal: true
 
-require 'elastic_apm/traceparent'
-
 module ElasticAPM
   # @api private
   class Middleware
@@ -53,13 +51,13 @@ module ElasticAPM
     def start_transaction(env)
       ElasticAPM.start_transaction 'Rack', 'request',
         context: ElasticAPM.build_context(env),
-        traceparent: traceparent(env)
+        trace_context: trace_context(env)
     end
 
-    def traceparent(env)
+    def trace_context(env)
       return unless (header = env['HTTP_ELASTIC_APM_TRACEPARENT'])
-      Traceparent.parse(header)
-    rescue Traceparent::InvalidTraceparentHeader
+      TraceContext.parse(header)
+    rescue TraceContext::InvalidTraceparentHeader
       warn "Couldn't parse invalid traceparent header: #{header.inspect}"
       nil
     end

data/lib/elastic_apm/opentracing.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require 'elastic_apm'
+require 'opentracing'
+
+module ElasticAPM
+  module OpenTracing
+    # @api private
+    class Span
+      def initialize(elastic_span, span_context)
+        @elastic_span = elastic_span
+        @span_context = span_context
+      end
+
+      attr_reader :elastic_span
+
+      def operation_name=(name)
+        elastic_span.name = name
+      end
+
+      def context
+        @span_context
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def set_tag(key, val)
+        if elastic_span.is_a?(Transaction)
+          case key.to_s
+          when 'type'
+            elastic_span.type = val
+          when 'result'
+            elastic_span.result = val
+          when /user\.(\w+)/
+            set_user_value($1, val)
+          else
+            elastic_span.context.tags[key] = val
+          end
+        else
+          elastic_span.context.tags[key] = val
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def set_baggage_item(_key, _value)
+        ElasticAPM.agent.config.logger.warn(
+          'Baggage is not supported by ElasticAPM'
+        )
+      end
+
+      def get_baggage_item(_key)
+        ElasticAPM.agent.config.logger.warn(
+          'Baggage is not supported by ElasticAPM'
+        )
+
+        nil
+      end
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def log_kv(timestamp: nil, **fields)
+        if (exception = fields[:'error.object'])
+          ElasticAPM.report exception
+        elsif (message = fields[:message])
+          ElasticAPM.report_message message
+        end
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      def finish(end_time: Time.now)
+        return unless (instrumenter = ElasticAPM.agent&.instrumenter)
+
+        elastic_span.done end_time: Util.micros(end_time)
+
+        case elastic_span
+        when ElasticAPM::Transaction
+          instrumenter.current_transaction = nil
+        when ElasticAPM::Span
+          instrumenter.current_spans.delete(elastic_span)
+        end
+
+        instrumenter.enqueue.call elastic_span
+      end
+
+      private
+
+      def set_user_value(key, value)
+        return unless elastic_span.is_a?(Transaction)
+
+        setter = :"#{key}="
+        return unless elastic_span.context.user.respond_to?(setter)
+        elastic_span.context.user.send(setter, value)
+      end
+    end
+
+    # @api private
+    class SpanContext
+      def initialize(id:, trace_id:, baggage: nil)
+        if baggage
+          ElasticAPM.agent.config.logger.warn(
+            'Baggage is not supported by ElasticAPM'
+          )
+        end
+
+        @id = id
+        @trace_id = trace_id
+        @trace_context =
+          ElasticAPM::TraceContext.new(trace_id: trace_id, span_id: id)
+      end
+
+      attr_accessor :id, :trace_id, :trace_context
+
+      def self.from_trace_context(trace_context)
+        new(
+          trace_id: trace_context.trace_id,
+          id: trace_context.span_id
+        ).tap do |span_context|
+          span_context.trace_context = trace_context
+        end
+      end
+    end
+
+    # @api private
+    class Scope
+      def initialize(span, scope_stack, finish_on_close:)
+        @span = span
+        @scope_stack = scope_stack
+        @finish_on_close = finish_on_close
+      end
+
+      attr_reader :span
+
+      def elastic_span
+        span.elastic_span
+      end
+
+      def close
+        @span.finish if @finish_on_close
+        @scope_stack.pop
+      end
+    end
+
+    # @api private
+    class ScopeStack
+      KEY = :__elastic_apm_ot_scope_stack
+
+      def push(scope)
+        scopes << scope
+      end
+
+      def pop
+        scopes.pop
+      end
+
+      def last
+        scopes.last
+      end
+
+      private
+
+      def scopes
+        Thread.current[KEY] ||= []
+      end
+    end
+
+    # @api private
+    class ScopeManager
+      def initialize
+        @scope_stack = ScopeStack.new
+      end
+
+      def activate(span, finish_on_close: true)
+        return active if active && active.span == span
+
+        scope = Scope.new(span, @scope_stack, finish_on_close: finish_on_close)
+        @scope_stack.push scope
+        scope
+      end
+
+      def active
+        @scope_stack.last
+      end
+    end
+
+    # rubocop:disable Metrics/ClassLength
+    # A custom tracer to use the OpenTracing API with ElasticAPM
+    class Tracer
+      def initialize
+        @scope_manager = ScopeManager.new
+      end
+
+      attr_reader :scope_manager
+
+      def active_span
+        scope_manager.active&.span
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      def start_active_span(
+        operation_name,
+        child_of: nil,
+        references: nil,
+        start_time: Time.now,
+        tags: {},
+        ignore_active_scope: false,
+        finish_on_close: true,
+        **
+      )
+        span = start_span(
+          operation_name,
+          child_of: child_of,
+          references: references,
+          start_time: start_time,
+          tags: tags,
+          ignore_active_scope: ignore_active_scope
+        )
+        scope = scope_manager.activate(span, finish_on_close: finish_on_close)
+
+        if block_given?
+          begin
+            yield scope
+          ensure
+            scope.close
+          end
+        end
+
+        scope
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      # rubocop:disable Metrics/AbcSize
+      def start_span(
+        operation_name,
+        child_of: nil,
+        references: nil,
+        start_time: Time.now,
+        tags: {},
+        ignore_active_scope: false,
+        **
+      )
+        span_context = prepare_span_context(
+          child_of: child_of,
+          references: references,
+          ignore_active_scope: ignore_active_scope
+        )
+
+        if span_context
+          trace_context =
+            span_context &&
+            span_context.respond_to?(:trace_context) &&
+            span_context.trace_context
+        end
+
+        elastic_span =
+          if ElasticAPM.current_transaction
+            ElasticAPM.start_span(
+              operation_name,
+              trace_context: trace_context
+            )
+          else
+            ElasticAPM.start_transaction(
+              operation_name,
+              trace_context: trace_context
+            )
+          end
+
+        # if no Elastic APM agent is running or transaction not sampled
+        unless elastic_span
+          return ::OpenTracing::Span::NOOP_INSTANCE
+        end
+
+        span_context ||=
+          SpanContext.from_trace_context(elastic_span.trace_context)
+
+        tags.each do |key, value|
+          elastic_span.context.tags[key] = value
+        end
+
+        elastic_span.start Util.micros(start_time)
+
+        Span.new(elastic_span, span_context)
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+      def inject(span_context, format, carrier)
+        case format
+        when ::OpenTracing::FORMAT_RACK
+          carrier['elastic-apm-traceparent'] = span_context.to_header
+        else
+          warn 'Only injection via HTTP headers and Rack is available'
+        end
+      end
+
+      def extract(format, carrier)
+        case format
+        when ::OpenTracing::FORMAT_RACK
+          ElasticAPM::TraceContext
+            .parse(carrier['HTTP_ELASTIC_APM_TRACEPARENT'])
+        else
+          warn 'Only extraction from HTTP headers via Rack is available'
+          nil
+        end
+      rescue ElasticAPM::TraceContext::InvalidTraceparentHeader
+        nil
+      end
+
+      private
+
+      def prepare_span_context(
+        child_of:,
+        references:,
+        ignore_active_scope:
+      )
+        context_from_child_of(child_of) ||
+          context_from_references(references) ||
+          context_from_active_scope(ignore_active_scope)
+      end
+
+      def context_from_child_of(child_of)
+        return unless child_of
+        child_of.respond_to?(:context) ? child_of.context : child_of
+      end
+
+      def context_from_references(references)
+        return if !references || references.none?
+
+        child_of = references.find do |reference|
+          reference.type == ::OpenTracing::Reference::CHILD_OF
+        end
+
+        (child_of || references.first).context
+      end
+
+      def context_from_active_scope(ignore_active_scope)
+        if ignore_active_scope
+          ElasticAPM.agent&.config&.logger&.warn(
+            'ignore_active_scope might lead to unexpeced results'
+          )
+          return
+        end
+        @scope_manager.active&.span&.context
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end