elastic-apm 1.1.0 → 2.0.0

data/lib/elastic_apm/metadata.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/metadata/service_info'
+require 'elastic_apm/metadata/system_info'
+require 'elastic_apm/metadata/process_info'
+
+module ElasticAPM
+  # @api private
+  module Metadata
+    def self.build(config)
+      {
+        metadata: {
+          service: Metadata::ServiceInfo.build(config),
+          process: Metadata::ProcessInfo.build(config),
+          system: Metadata::SystemInfo.build(config)
+        }
+      }.to_json
+    end
+  end
+end

data/lib/elastic_apm/metadata/process_info.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metadata
+    # @api private
+    class ProcessInfo
+      def initialize(config)
+        @config = config
+      end
+
+      def build
+        pid = $PID || Process.pid
+        return unless pid
+        {
+          argv: ARGV,
+          pid: pid,
+          title: $PROGRAM_NAME
+        }
+      end
+
+      def self.build(config)
+        new(config).build
+      end
+    end
+  end
+end

data/lib/elastic_apm/metadata/service_info.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metadata
+    # @api private
+    class ServiceInfo
+      def initialize(config)
+        @config = config
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def build
+        base = {
+          name: @config.service_name,
+          environment: @config.environment,
+          agent: {
+            name: 'ruby',
+            version: VERSION
+          },
+          framework: nil,
+          language: {
+            name: 'ruby',
+            version: RUBY_VERSION
+          },
+          runtime: runtime,
+          version: @config.service_version || Util.git_sha
+        }
+
+        if @config.framework_name
+          base[:framework] = {
+            name: @config.framework_name,
+            version: @config.framework_version
+          }
+        end
+
+        base
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def self.build(config)
+        new(config).build
+      end
+
+      private
+
+      def runtime
+        case RUBY_ENGINE
+        when 'ruby'
+          { name: RUBY_ENGINE, version: RUBY_VERSION || RUBY_ENGINE_VERSION }
+        when 'jruby'
+          { name: RUBY_ENGINE, version: JRUBY_VERSION || RUBY_ENGINE_VERSION }
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/metadata/system_info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metadata
+    # @api private
+    class SystemInfo
+      def initialize(config)
+        @config = config
+      end
+
+      def build
+        {
+          hostname: @config.hostname || `hostname`.chomp,
+          architecture: platform.cpu,
+          platform: platform.os
+        }
+      end
+
+      def self.build(config)
+        new(config).build
+      end
+
+      private
+
+      def platform
+        @platform ||= Gem::Platform.local
+      end
+    end
+  end
+end

data/lib/elastic_apm/middleware.rb

@@ -1,40 +1,47 @@
+#
 # frozen_string_literal: true
 
+require 'elastic_apm/traceparent'
+
 module ElasticAPM
   # @api private
   class Middleware
+    include Logging
+
     def initialize(app)
       @app = app
     end
 
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength
     def call(env)
       begin
         if running? && !path_ignored?(env)
-          transaction = build_transaction(env)
+          transaction = start_transaction(env)
         end
 
         resp = @app.call env
-
-        status, headers, body = resp
-        submit_transaction(transaction, status, headers, body) if transaction
       rescue InternalError
         raise # Don't report ElasticAPM errors
       rescue ::Exception => e
         ElasticAPM.report(e, handled: false)
-        transaction.submit('HTTP 5xx', status: 500) if transaction
         raise
       ensure
-        transaction.release if transaction
+        if resp && transaction
+          status, headers, _body = resp
+          transaction.add_response(status, headers: headers)
+        end
+
+        ElasticAPM.end_transaction http_result(status)
       end
 
       resp
     end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:enable Metrics/MethodLength
+
+    private
 
-    def submit_transaction(transaction, status, headers, _body)
-      result = "HTTP #{status.to_s[0]}xx"
-      transaction.submit(result, status: status, headers: headers)
+    def http_result(status)
+      status && "HTTP #{status.to_s[0]}xx"
     end
 
     def path_ignored?(env)
@@ -43,9 +50,18 @@ module ElasticAPM
       end
     end
 
-    def build_transaction(env)
-      ElasticAPM.transaction 'Rack', 'request',
-        context: ElasticAPM.build_context(env)
+    def start_transaction(env)
+      ElasticAPM.start_transaction 'Rack', 'request',
+        context: ElasticAPM.build_context(env),
+        traceparent: traceparent(env)
+    end
+
+    def traceparent(env)
+      return unless (header = env['HTTP_ELASTIC_APM_TRACEPARENT'])
+      Traceparent.parse(header)
+    rescue Traceparent::InvalidTraceparentHeader
+      warn "Couldn't parse invalid traceparent header: #{header.inspect}"
+      nil
     end
 
     def running?
@@ -53,7 +69,7 @@ module ElasticAPM
     end
 
     def config
-      ElasticAPM.agent.config
+      @config ||= ElasticAPM.agent.config
     end
   end
 end

data/lib/elastic_apm/normalizers/action_controller.rb

@@ -6,7 +6,7 @@ module ElasticAPM
       # @api private
       class ProcessActionNormalizer < Normalizer
         register 'process_action.action_controller'
-        TYPE = 'app.controller.action'.freeze
+        TYPE = 'app.controller.action'
 
         def normalize(transaction, _name, payload)
           transaction.name = endpoint(payload)

data/lib/elastic_apm/normalizers/action_mailer.rb

@@ -6,7 +6,7 @@ module ElasticAPM
       # @api private
       class ProcessActionNormalizer < Normalizer
         register 'process.action_mailer'
-        TYPE = 'app.mailer.action'.freeze
+        TYPE = 'app.mailer.action'
 
         def normalize(_transaction, _name, payload)
           [endpoint(payload), TYPE, nil]

data/lib/elastic_apm/normalizers/action_view.rb

@@ -41,7 +41,7 @@ module ElasticAPM
       # @api private
       class RenderTemplateNormalizer < RenderNormalizer
         register 'render_template.action_view'
-        TYPE = 'template.view'.freeze
+        TYPE = 'template.view'
 
         def normalize(_transaction, _name, payload)
           normalize_render(payload, TYPE)
@@ -51,7 +51,7 @@ module ElasticAPM
       # @api private
       class RenderPartialNormalizer < RenderNormalizer
         register 'render_partial.action_view'
-        TYPE = 'template.view.partial'.freeze
+        TYPE = 'template.view.partial'
 
         def normalize(_transaction, _name, payload)
           normalize_render(payload, TYPE)
@@ -61,7 +61,7 @@ module ElasticAPM
       # @api private
       class RenderCollectionNormalizer < RenderNormalizer
         register 'render_collection.action_view'
-        TYPE = 'template.view.collection'.freeze
+        TYPE = 'template.view.collection'
 
         def normalize(_transaction, _name, payload)
           normalize_render(payload, TYPE)

data/lib/elastic_apm/normalizers/active_record.rb

@@ -20,7 +20,8 @@ module ElasticAPM
           return :skip if %w[SCHEMA CACHE].include?(payload[:name])
 
           name = summarize(payload[:sql]) || payload[:name]
-          context = Span::Context.new(statement: payload[:sql], type: 'sql')
+          context =
+            Span::Context.new(db: { statement: payload[:sql], type: 'sql' })
           [name, @type, context]
         end
 

data/lib/elastic_apm/railtie.rb

@@ -26,7 +26,7 @@ module ElasticAPM
           app.middleware.insert 0, Middleware
         end
       rescue StandardError => e
-        Rails.logger.error "#{Log::PREFIX}Failed to start: #{e.message}"
+        Rails.logger.error "#{Logging::PREFIX}Failed to start: #{e.message}"
         Rails.logger.debug e.backtrace.join("\n")
       end
     end

data/lib/elastic_apm/span.rb

@@ -7,61 +7,82 @@ require 'elastic_apm/span/context'
 module ElasticAPM
   # @api private
   class Span
-    DEFAULT_TYPE = 'custom'.freeze
+    DEFAULT_TYPE = 'custom'
 
     # rubocop:disable Metrics/ParameterLists
     def initialize(
-      transaction,
-      id,
       name,
       type = nil,
+      transaction: nil,
       parent: nil,
-      context: nil
+      context: nil,
+      stacktrace_builder: nil
     )
-      @transaction = transaction
-      @id = id
       @name = name
       @type = type || DEFAULT_TYPE
-      @parent = parent
-      @context = context
 
-      @stacktrace = nil
-      @original_backtrace = nil
+      @id = SecureRandom.hex(8)
+
+      self.transaction = transaction
+      self.parent = parent
+
+      @context = context
+      @stacktrace_builder = stacktrace_builder
     end
     # rubocop:enable Metrics/ParameterLists
 
-    attr_accessor :name, :type, :original_backtrace
-    attr_reader :id, :context, :stacktrace, :duration, :parent, :relative_start
+    attr_accessor :name, :type, :original_backtrace, :parent
+    attr_reader :id, :context, :stacktrace, :duration,
+      :relative_start, :timestamp, :transaction_id, :trace_id
+
+    def transaction=(transaction)
+      @transaction_id = transaction&.id
+      @timestamp = transaction&.timestamp
+      @trace_id = transaction&.trace_id
+    end
+
+    def parent_id
+      @parent&.id || transaction_id
+    end
+
+    # life cycle
 
     def start
-      @relative_start = Util.micros - @transaction.timestamp
+      raise 'Transaction needed to start span' unless transaction_id
+
+      @relative_start = Util.micros - timestamp
 
       self
     end
 
+    def stop
+      @duration = Util.micros - timestamp - relative_start
+    end
+
     def done
-      @duration = Util.micros - @transaction.timestamp - relative_start
+      stop
 
-      if original_backtrace && long_enough_for_stacktrace?
-        @stacktrace =
-          @transaction.instrumenter.agent.stacktrace_builder.build(
-            original_backtrace, type: :span
-          )
+      if should_build_stacktrace?
+        build_stacktrace
       end
 
-      self.original_backtrace = nil # release it
-
       self
     end
 
-    def done?
+    def stopped?
       !!duration
     end
 
+    def started?
+      !!relative_start
+    end
+
     def running?
-      relative_start && !done?
+      started? && !stopped?
     end
 
+    # relations
+
     def inspect
       "<ElasticAPM::Span id:#{id}" \
         " name:#{name.inspect}" \
@@ -71,14 +92,23 @@ module ElasticAPM
 
     private
 
+    def should_build_stacktrace?
+      @stacktrace_builder && original_backtrace && long_enough_for_stacktrace?
+    end
+
+    def build_stacktrace
+      @stacktrace = @stacktrace_builder.build(original_backtrace, type: :span)
+      self.original_backtrace = nil # release it
+    end
+
     def long_enough_for_stacktrace?
-      min_duration = @transaction.instrumenter.config.span_frames_min_duration
+      min_duration =
+        @stacktrace_builder.config.span_frames_min_duration_us
 
-      case min_duration
-      when -1 then true
-      when 0 then false
-      else duration / 1000 >= min_duration
-      end
+      return true if min_duration < 0
+      return false if min_duration == 0
+
+      duration >= min_duration
     end
   end
 end

data/lib/elastic_apm/span/context.rb

@@ -6,13 +6,39 @@ module ElasticAPM
     class Context
       include NaivelyHashable
 
-      def initialize(args)
-        args.each do |key, val|
-          send(:"#{key}=", val)
+      def initialize(db: nil, http: nil)
+        @db = db && Db.new(db)
+        @http = http && Http.new(http)
+      end
+
+      attr_accessor :sync, :db, :http
+
+      # @api private
+      class Db
+        include NaivelyHashable
+
+        def initialize(instance: nil, statement: nil, type: nil, user: nil)
+          @instance = instance
+          @statement = statement
+          @type = type
+          @user = user
         end
+
+        attr_accessor :instance, :statement, :type, :user
       end
 
-      attr_accessor :instance, :statement, :type, :user
+      # @api private
+      class Http
+        include NaivelyHashable
+
+        def initialize(url: nil, status_code: nil, method: nil)
+          @url = url
+          @status_code = status_code
+          @method = method
+        end
+
+        attr_accessor :url, :status_code, :method
+      end
     end
   end
 end