elastic-apm 1.1.0 → 2.0.0

data/lib/elastic_apm/config/duration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Config
+    # @api private
+    class Duration
+      MULTIPLIERS = { 'ms' => 0.001, 'm' => 60 }.freeze
+      REGEX = /^(-)?(\d+)(m|ms|s)?$/i.freeze
+
+      def initialize(seconds)
+        @seconds = seconds
+      end
+
+      attr_accessor :seconds
+
+      def self.parse(str, default_unit:)
+        _, negative, amount, unit = REGEX.match(str).to_a
+        unit ||= default_unit
+        seconds = MULTIPLIERS.fetch(unit.downcase, 1) * amount.to_i
+        seconds = 0 - seconds if negative
+        new(seconds)
+      end
+    end
+  end
+end

data/lib/elastic_apm/config/size.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Config
+    # @api private
+    class Size
+      MULTIPLIERS = {
+        'kb' => 1024,
+        'mb' => 1024 * 1_000,
+        'gb' => 1024 * 100_000
+      }.freeze
+      REGEX = /^(\d+)(b|kb|mb|gb)?$/i.freeze
+
+      def initialize(bytes)
+        @bytes = bytes
+      end
+
+      attr_accessor :bytes
+
+      def self.parse(str, default_unit:)
+        _, amount, unit = REGEX.match(str).to_a
+        unit ||= default_unit
+        bytes = MULTIPLIERS.fetch(unit.downcase, 1) * amount.to_i
+        new(bytes)
+      end
+    end
+  end
+end

data/lib/elastic_apm/context_builder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module ElasticAPM
+  # TODO: Move to txn.add_request ?
   # @api private
   class ContextBuilder
     def initialize(_agent); end

data/lib/elastic_apm/deprecations.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Deprecations
+    def deprecate(name, replacement = nil)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        alias :"#{name}__deprecated" :"#{name}"
+
+        def #{name}(*args, &block)
+          warn "[ElasticAPM] [DEPRECATED] `#{name}' is being removed. " \
+            "#{replacement && "See `#{replacement}'."}" \
+            "\nCalled from \#{caller.first}"
+          #{name}__deprecated(*args, &block)
+        end
+      RUBY
+    end
+  end
+end

data/lib/elastic_apm/error.rb

@@ -9,16 +9,19 @@ module ElasticAPM
   # @api private
   class Error
     def initialize(culprit: nil)
-      @id = SecureRandom.uuid
+      @id = SecureRandom.hex(16)
+      @trace_id = nil
       @culprit = culprit
 
       @timestamp = Util.micros
       @context = Context.new
 
       @transaction_id = nil
+      @parent_id = nil
     end
 
-    attr_accessor :id, :culprit, :exception, :log, :transaction_id, :context
+    attr_accessor :id, :culprit, :exception, :log, :transaction_id, :context,
+      :parent_id, :trace_id
     attr_reader :timestamp
   end
 end

data/lib/elastic_apm/error/exception.rb

@@ -4,7 +4,7 @@ module ElasticAPM
   class Error
     # @api private
     class Exception
-      MOD_SPLIT = '::'.freeze
+      MOD_SPLIT = '::'
 
       def initialize(exception, **attrs)
         @message =

data/lib/elastic_apm/error_builder.rb

@@ -7,6 +7,7 @@ module ElasticAPM
       @agent = agent
     end
 
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def build_exception(exception, handled: true)
       error = Error.new
       error.exception = Error::Exception.new(exception, handled: handled)
@@ -19,10 +20,14 @@ module ElasticAPM
 
       if (transaction = ElasticAPM.current_transaction)
         error.context = transaction.context.dup
+        error.trace_id = transaction.trace_id
+        error.transaction_id = transaction.id
+        error.parent_id = ElasticAPM.current_span&.id || transaction.id
       end
 
       error
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def build_log(message, backtrace: nil, **attrs)
       error = Error.new

data/lib/elastic_apm/instrumenter.rb

@@ -4,41 +4,57 @@ require 'elastic_apm/span'
 require 'elastic_apm/transaction'
 
 module ElasticAPM
+  # rubocop:disable Metrics/ClassLength
   # @api private
   class Instrumenter
-    include Log
+    include Logging
 
-    KEY = :__elastic_transaction_key
+    TRANSACTION_KEY = :__elastic_transaction_key
+    SPAN_KEY = :__elastic_span_key
 
     # @api private
-    class TransactionInfo
+    class Current
       def initialize
-        self.current = nil
+        self.transaction = nil
+        self.span = nil
       end
 
-      def current
-        Thread.current[KEY]
+      def transaction
+        Thread.current[TRANSACTION_KEY]
       end
 
-      def current=(transaction)
-        Thread.current[KEY] = transaction
+      def transaction=(transaction)
+        Thread.current[TRANSACTION_KEY] = transaction
+      end
+
+      def span
+        Thread.current[SPAN_KEY]
+      end
+
+      def span=(span)
+        Thread.current[SPAN_KEY] = span
       end
     end
 
-    def initialize(agent)
-      @agent = agent
-      @config = agent.config
+    def initialize(config, &enqueue)
+      @config = config
+      @enqueue = enqueue
 
-      @transaction_info = TransactionInfo.new
+      @current = Current.new
     end
 
-    attr_reader :agent, :config, :pending_transactions
+    attr_reader :config, :enqueue
 
     def start
+      debug 'Starting instrumenter'
     end
 
     def stop
-      current_transaction.release if current_transaction
+      debug 'Stopping instrumenter'
+
+      self.current_transaction = nil
+      self.current_span = nil
+
       @subscriber.unregister! if @subscriber
     end
 
@@ -47,70 +63,118 @@ module ElasticAPM
       @subscriber.register!
     end
 
+    # transactions
+
     def current_transaction
-      @transaction_info.current
+      @current.transaction
     end
 
     def current_transaction=(transaction)
-      @transaction_info.current = transaction
+      @current.transaction = transaction
     end
 
     # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Metrics/CyclomaticComplexity
-    def transaction(name = nil, type = nil, context: nil, sampled: nil)
-      unless config.instrument
-        yield if block_given?
-        return
-      end
+    def start_transaction(
+      name = nil,
+      type = nil,
+      context: nil,
+      traceparent: nil
+    )
+      return nil unless config.instrument?
 
       if (transaction = current_transaction)
-        yield transaction if block_given?
-        return transaction
+        raise ExistingTransactionError,
+          "Transactions may not be nested.\nAlready inside #{transaction}"
       end
 
-      sampled = random_sample? if sampled.nil?
+      sampled = traceparent ? traceparent.recorded? : random_sample?
 
       transaction =
-        Transaction.new self, name, type, context: context, sampled: sampled
+        Transaction.new(
+          name,
+          type,
+          context: context,
+          traceparent: traceparent,
+          sampled: sampled
+        )
+
+      transaction.start
 
       self.current_transaction = transaction
-      return transaction unless block_given?
+    end
+    # rubocop:enable Metrics/MethodLength
 
-      begin
-        yield transaction
-      ensure
-        self.current_transaction = nil
-        transaction.done
-      end
+    def end_transaction(result = nil)
+      return nil unless (transaction = current_transaction)
+
+      self.current_transaction = nil
+
+      transaction.done result
+
+      enqueue.call transaction
 
       transaction
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/MethodLength
 
-    def random_sample?
-      rand <= config.transaction_sample_rate
+    # spans
+
+    def current_span
+      @current.span
     end
 
-    # rubocop:disable Metrics/MethodLength
-    def span(name, type = nil, backtrace: nil, context: nil, &block)
-      unless current_transaction
-        return yield if block_given?
+    def current_span=(span)
+      @current.span = span
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    def start_span(name, type = nil, backtrace: nil, context: nil)
+      return unless (transaction = current_transaction)
+      return unless transaction.sampled?
+
+      transaction.inc_started_spans!
+
+      if transaction.max_spans_reached?(config)
+        transaction.inc_dropped_spans!
         return
       end
 
-      current_transaction.span(
+      span = Span.new(
         name,
         type,
-        backtrace: backtrace,
-        context: context,
-        &block
+        transaction: transaction,
+        parent: current_span || transaction,
+        context: context
       )
+
+      if backtrace && span_frames_min_duration?
+        span.original_backtrace = backtrace
+      end
+
+      self.current_span = span
+
+      span.start
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+
+    def end_span
+      return unless (span = current_span)
+
+      span.done
+
+      self.current_span =
+        span.parent&.is_a?(Span) && span.parent || nil
+
+      enqueue.call span
+
+      span
     end
-    # rubocop:enable Metrics/MethodLength
+
+    # metadata
 
     def set_tag(key, value)
       return unless current_transaction
+
+      key = key.to_s.gsub(/[\."\*]/, '_').to_sym
       current_transaction.context.tags[key] = value.to_s
     end
 
@@ -124,17 +188,21 @@ module ElasticAPM
       current_transaction.context.user = Context::User.new(config, user)
     end
 
-    def submit_transaction(transaction)
-      agent.enqueue_transaction transaction
-
-      return unless config.debug_transactions
-      debug('Submitted transaction:') { Util.inspect_transaction transaction }
-    end
-
     def inspect
       '<ElasticAPM::Instrumenter ' \
         "current_transaction=#{current_transaction.inspect}" \
         '>'
     end
+
+    private
+
+    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/internal_error.rb

@@ -2,4 +2,5 @@
 
 module ElasticAPM
   class InternalError < StandardError; end
+  class ExistingTransactionError < InternalError; end
 end

data/lib/elastic_apm/{log.rb → logging.rb}

@@ -1,9 +1,19 @@
 # frozen_string_literal: true
 
+require 'logger'
+
 module ElasticAPM
   # @api private
-  module Log
-    PREFIX = '[ElasticAPM] '.freeze
+  module Logging
+    PREFIX = '[ElasticAPM] '
+
+    LEVELS = {
+      debug: Logger::DEBUG,
+      info: Logger::INFO,
+      warn: Logger::WARN,
+      error: Logger::ERROR,
+      fatal: Logger::FATAL
+    }.freeze
 
     def debug(msg, *args, &block)
       log(:debug, msg, *args, &block)
@@ -25,26 +35,21 @@ module ElasticAPM
       log(:fatal, msg, *args, &block)
     end
 
+    private
+
     def log(lvl, msg, *args)
-      return unless logger
+      return unless (logger = @config&.logger)
+      return unless LEVELS[lvl] >= (@config&.log_level || 0)
 
       formatted_msg = prepend_prefix(format(msg.to_s, *args))
 
       return logger.send(lvl, formatted_msg) unless block_given?
 
-      # TODO: dont evaluate block if level is higher
       logger.send(lvl, "#{formatted_msg}\n#{yield}")
     end
 
-    private
-
     def prepend_prefix(str)
       "#{PREFIX}#{str}"
     end
-
-    def logger
-      return false unless (config = instance_variable_get(:@config))
-      config.logger
-    end
   end
 end