elastic-apm 3.1.0 → 3.2.0

data/lib/elastic_apm/error/exception.rb

@@ -34,6 +34,13 @@ module ElasticAPM
         :cause
       )
 
+      def inspect
+        "<ElasticAPM::Error::Exception" \
+          " type:#{type}" \
+          " message:#{message}" \
+          ">"
+      end
+
       class << self
         private
 

data/lib/elastic_apm/grape.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/subscriber'
+require 'elastic_apm/normalizers/grape'
+
+module ElasticAPM
+  # Module for starting the ElasticAPM agent and hooking into Grape.
+  module Grape
+    extend self
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # Start the ElasticAPM agent and hook into Grape.
+    #
+    # @param app [Grape::API] A Grape app.
+    # @param config [Config, Hash] An instance of Config or a Hash config.
+    # @return [true, nil] true if the agent was started, nil otherwise.
+    def start(app, config = {})
+      config = Config.new(config) unless config.is_a?(Config)
+      configure_app(app, config)
+
+      ElasticAPM.start(config).tap do |agent|
+        attach_subscriber(agent)
+      end
+
+      ElasticAPM.running?
+    rescue StandardError => e
+      config.logger.error format('Failed to start: %s', e.message)
+      config.logger.debug "Backtrace:\n" + e.backtrace.join("\n")
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    private
+
+    def configure_app(app, config)
+      config.service_name ||= app.name
+      config.framework_name ||= 'Grape'
+      config.framework_version ||= ::Grape::VERSION
+      config.logger ||= app.logger
+      config.__root_path ||= Dir.pwd
+    end
+
+    def attach_subscriber(agent)
+      return unless agent
+
+      agent.instrumenter.subscriber = ElasticAPM::Subscriber.new(agent)
+    end
+  end
+end

data/lib/elastic_apm/instrumenter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'elastic_apm/trace_context'
+require 'elastic_apm/child_durations'
 require 'elastic_apm/span'
 require 'elastic_apm/transaction'
 require 'elastic_apm/span_helpers'
@@ -39,10 +40,11 @@ module ElasticAPM
       end
     end
 
-    def initialize(config, stacktrace_builder:, &enqueue)
+    def initialize(config, metrics:, stacktrace_builder:, &enqueue)
       @config = config
       @stacktrace_builder = stacktrace_builder
       @enqueue = enqueue
+      @metrics = metrics
 
       @current = Current.new
     end
@@ -90,7 +92,8 @@ module ElasticAPM
 
       if (transaction = current_transaction)
         raise ExistingTransactionError,
-          "Transactions may not be nested.\nAlready inside #{transaction}"
+          "Transactions may not be nested.\n" \
+          "Already inside #{transaction.inspect}"
       end
 
       sampled = trace_context ? trace_context.recorded? : random_sample?(config)
@@ -120,6 +123,8 @@ module ElasticAPM
 
       enqueue.call transaction
 
+      update_transaction_metrics(transaction)
+
       transaction
     end
 
@@ -161,8 +166,9 @@ module ElasticAPM
         name: name,
         subtype: subtype,
         action: action,
-        transaction_id: transaction.id,
-        trace_context: trace_context || parent.trace_context.child,
+        transaction: transaction,
+        parent: parent,
+        trace_context: trace_context,
         type: type,
         context: context,
         stacktrace_builder: stacktrace_builder
@@ -187,6 +193,8 @@ module ElasticAPM
 
       enqueue.call span
 
+      update_span_metrics(span)
+
       span
     end
 
@@ -220,6 +228,71 @@ module ElasticAPM
     def random_sample?(config)
       rand <= config.transaction_sample_rate
     end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def update_transaction_metrics(transaction)
+      return unless transaction.config.collect_metrics?
+
+      tags = {
+        'transaction.name': transaction.name,
+        'transaction.type': transaction.type
+      }
+
+      @metrics.get(:transaction).timer(
+        :'transaction.duration.sum.us',
+        tags: tags, reset_on_collect: true
+      ).update(transaction.duration)
+
+      @metrics.get(:transaction).counter(
+        :'transaction.duration.count',
+        tags: tags, reset_on_collect: true
+      ).inc!
+
+      return unless transaction.sampled?
+      return unless transaction.config.breakdown_metrics?
+
+      @metrics.get(:breakdown).counter(
+        :'transaction.breakdown.count',
+        tags: tags, reset_on_collect: true
+      ).inc!
+
+      span_tags = tags.merge('span.type': 'app')
+
+      @metrics.get(:breakdown).timer(
+        :'span.self_time.sum.us',
+        tags: span_tags, reset_on_collect: true
+      ).update(transaction.self_time)
+
+      @metrics.get(:breakdown).counter(
+        :'span.self_time.count',
+        tags: span_tags, reset_on_collect: true
+      ).inc!
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def update_span_metrics(span)
+      return unless span.transaction.config.breakdown_metrics?
+
+      tags = {
+        'span.type': span.type,
+        'transaction.name': span.transaction.name,
+        'transaction.type': span.transaction.type
+      }
+
+      tags[:'span.subtype'] = span.subtype if span.subtype
+
+      @metrics.get(:breakdown).timer(
+        :'span.self_time.sum.us',
+        tags: tags, reset_on_collect: true
+      ).update(span.self_time)
+
+      @metrics.get(:breakdown).counter(
+        :'span.self_time.count',
+        tags: tags, reset_on_collect: true
+      ).inc!
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
   end
   # rubocop:enable Metrics/ClassLength
 end

data/lib/elastic_apm/logging.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'logger'
-
 module ElasticAPM
   # @api private
   module Logging

data/lib/elastic_apm/metrics.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require 'elastic_apm/metricset'
-
 module ElasticAPM
   # @api private
   module Metrics
-    MUTEX = Mutex.new
-
     def self.new(config, &block)
-      Collector.new(config, &block)
+      Registry.new(config, &block)
     end
 
     def self.platform
@@ -16,24 +12,19 @@ module ElasticAPM
     end
 
     # @api private
-    class Collector
+    class Registry
       include Logging
 
       TIMEOUT_INTERVAL = 5 # seconds
 
-      def initialize(config, labels: nil, &block)
+      def initialize(config, &block)
         @config = config
-        @labels = labels
-        @samplers = [CpuMem, VM].map do |kls|
-          debug "Adding metrics collector '#{kls}'"
-          kls.new(config)
-        end
         @callback = block
       end
 
-      attr_reader :config, :samplers, :callback, :labels
+      attr_reader :config, :sets, :callback
 
-      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def start
         unless config.collect_metrics?
           debug 'Skipping metrics'
@@ -42,6 +33,16 @@ module ElasticAPM
 
         debug 'Starting metrics'
 
+        @sets = {
+          system: CpuMemSet,
+          vm: VMSet,
+          breakdown: BreakdownSet,
+          transaction: TransactionSet
+        }.each_with_object({}) do |(key, kls), sets|
+          debug "Adding metrics collector '#{kls}'"
+          sets[key] = kls.new(config)
+        end
+
         @timer_task = Concurrent::TimerTask.execute(
           run_now: true,
           execution_interval: config.metrics_interval,
@@ -60,7 +61,7 @@ module ElasticAPM
 
         @running = true
       end
-      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       def stop
         return unless running?
@@ -75,24 +76,36 @@ module ElasticAPM
         !!@running
       end
 
-      def collect_and_send
-        metricset = Metricset.new(labels: labels, **collect)
-        return if metricset.empty?
+      def get(key)
+        sets.fetch(key)
+      end
 
-        callback.call(metricset)
+      def collect_and_send
+        metricsets = collect
+        metricsets.compact!
+        metricsets.each do |m|
+          callback.call(m)
+        end
       end
 
       def collect
-        MUTEX.synchronize do
-          samplers.each_with_object({}) do |sampler, samples|
-            next unless (sample = sampler.collect)
-            samples.merge!(sample)
-          end
+        sets.each_value.each_with_object([]) do |set, arr|
+          samples = set.collect
+          next unless samples
+          arr.concat(samples)
         end
       end
     end
   end
 end
 
-require 'elastic_apm/metrics/cpu_mem'
-require 'elastic_apm/metrics/vm'
+require 'elastic_apm/metricset'
+
+require 'elastic_apm/metrics/metric'
+require 'elastic_apm/metrics/set'
+
+require 'elastic_apm/metrics/cpu_mem_set'
+require 'elastic_apm/metrics/vm_set'
+require 'elastic_apm/metrics/span_scoped_set'
+require 'elastic_apm/metrics/transaction_set'
+require 'elastic_apm/metrics/breakdown_set'

data/lib/elastic_apm/metrics/breakdown_set.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metrics
+    # @api private
+    class BreakdownSet < SpanScopedSet
+      def initialize(config)
+        super
+
+        disable! unless config.breakdown_metrics?
+      end
+    end
+  end
+end

data/lib/elastic_apm/metrics/{cpu_mem.rb → cpu_mem_set.rb}

@@ -3,100 +3,108 @@
 module ElasticAPM
   module Metrics
     # @api private
-    class CpuMem
+    class CpuMemSet < Set
       include Logging
 
       # @api private
       class Sample
         # rubocop:disable Metrics/ParameterLists
         def initialize(
+          page_size:,
+          process_cpu_usage:,
+          process_memory_rss:,
+          process_memory_size:,
           system_cpu_total:,
           system_cpu_usage:,
-          system_memory_total:,
           system_memory_free:,
-          process_cpu_usage:,
-          process_memory_size:,
-          process_memory_rss:,
-          page_size:
+          system_memory_total:
         )
+          @page_size = page_size
+          @process_cpu_usage = process_cpu_usage
+          @process_memory_rss = process_memory_rss
+          @process_memory_size = process_memory_size
           @system_cpu_total = system_cpu_total
           @system_cpu_usage = system_cpu_usage
-          @system_memory_total = system_memory_total
           @system_memory_free = system_memory_free
-          @process_cpu_usage = process_cpu_usage
-          @process_memory_size = process_memory_size
-          @process_memory_rss = process_memory_rss
-          @page_size = page_size
+          @system_memory_total = system_memory_total
         end
         # rubocop:enable Metrics/ParameterLists
 
-        attr_accessor :system_cpu_total, :system_cpu_usage,
-          :system_memory_total, :system_memory_free, :process_cpu_usage,
-          :process_memory_size, :process_memory_rss, :page_size
-
-        def delta(previous)
-          dup.tap do |sample|
-            sample.system_cpu_total =
-              system_cpu_total - previous.system_cpu_total
-            sample.system_cpu_usage =
-              system_cpu_usage - previous.system_cpu_usage
-            sample.process_cpu_usage =
-              process_cpu_usage - previous.process_cpu_usage
-          end
-        end
+        attr_accessor(
+          :page_size,
+          :process_cpu_usage,
+          :process_memory_rss,
+          :process_memory_size,
+          :system_cpu_total,
+          :system_cpu_usage,
+          :system_memory_free,
+          :system_memory_total
+        )
       end
 
       def initialize(config)
-        @config = config
+        super
+
         @sampler = sampler_for_platform(Metrics.platform)
+        read! # set @previous on boot
       end
 
-      attr_reader :config, :sampler
+      attr_reader :config
 
-      def sample
-        @sampler.sample
+      def collect
+        read!
+        super
+      end
+
+      private
+
+      def sampler_for_platform(platform)
+        case platform
+        when :linux then Linux.new
+        else
+          warn "Unsupported platform '#{platform}' - Disabling system metrics"
+          disable!
+          nil
+        end
       end
 
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      def collect
-        return unless sampler
+      def read!
+        return if disabled?
 
-        current = sample
+        current = @sampler.sample
 
         unless @previous
           @previous = current
           return
         end
 
-        delta = current.delta(@previous)
+        cpu_usage_pct, cpu_process_pct = calculate_deltas(current, @previous)
 
-        cpu_usage_pct = delta.system_cpu_usage.to_f / delta.system_cpu_total
-        cpu_process_pct = delta.process_cpu_usage.to_f / delta.system_cpu_total
+        gauge(:'system.cpu.total.norm.pct').value = cpu_usage_pct
+        gauge(:'system.memory.actual.free').value = current.system_memory_free
+        gauge(:'system.memory.total').value = current.system_memory_total
+        gauge(:'system.process.cpu.total.norm.pct').value = cpu_process_pct
+        gauge(:'system.process.memory.size').value = current.process_memory_size
+        gauge(:'system.process.memory.rss.bytes').value =
+          current.process_memory_rss * current.page_size
 
         @previous = current
-
-        {
-          'system.cpu.total.norm.pct': cpu_usage_pct,
-          'system.memory.actual.free': current.system_memory_free,
-          'system.memory.total': current.system_memory_total,
-          'system.process.cpu.total.norm.pct': cpu_process_pct,
-          'system.process.memory.size': current.process_memory_size,
-          'system.process.memory.rss.bytes':
-            current.process_memory_rss * current.page_size
-        }
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-      private
+      def calculate_deltas(current, previous)
+        system_cpu_total =
+          current.system_cpu_total - previous.system_cpu_total
+        system_cpu_usage =
+          current.system_cpu_usage - previous.system_cpu_usage
+        process_cpu_usage =
+          current.process_cpu_usage - previous.process_cpu_usage
 
-      def sampler_for_platform(platform)
-        case platform
-        when :linux then Linux.new
-        else
-          warn "Unsupported platform '#{platform}' - Disabling metrics"
-          @disabled = true
-          nil
-        end
+        cpu_usage_pct = system_cpu_usage.to_f / system_cpu_total
+        cpu_process_pct = process_cpu_usage.to_f / system_cpu_total
+
+        [cpu_usage_pct, cpu_process_pct]
       end
 
       # @api private