elastic-apm 3.1.0 → 3.2.0

data/lib/elastic_apm/metrics/metric.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metrics
+    # @api private
+    class Metric
+      def initialize(
+        key,
+        initial_value: nil,
+        tags: nil,
+        reset_on_collect: false
+      )
+        @key = key
+        @initial_value = initial_value
+        @value = initial_value
+        @tags = tags
+        @reset_on_collect = reset_on_collect
+        @mutex = Mutex.new
+      end
+
+      attr_reader :key, :initial_value, :tags, :value
+
+      def value=(value)
+        @mutex.synchronize { @value = value }
+      end
+
+      def reset!
+        self.value = initial_value
+      end
+
+      def tags?
+        !!tags&.any?
+      end
+
+      def reset_on_collect?
+        @reset_on_collect
+      end
+
+      def collect
+        collected = value
+
+        self.value = initial_value if reset_on_collect?
+
+        return nil if reset_on_collect? && collected == 0
+
+        collected
+      end
+    end
+
+    # @api private
+    class NoopMetric
+      def value; end
+
+      def value=(_); end
+
+      def collect; end
+
+      def reset!; end
+
+      def tags?; end
+
+      def reset_on_collect?; end
+
+      def inc!; end
+
+      def dec!; end
+
+      def update(_, delta: nil); end
+    end
+
+    # @api private
+    class Counter < Metric
+      def initialize(key, initial_value: 0, **args)
+        super(key, initial_value: initial_value, **args)
+      end
+
+      def inc!
+        @value += 1
+      end
+
+      def dec!
+        @value -= 1
+      end
+    end
+
+    # @api private
+    class Gauge < Metric
+      def initialize(key, **args)
+        super(key, initial_value: 0, **args)
+      end
+    end
+
+    # @api private
+    class Timer < Metric
+      def initialize(key, **args)
+        super(key, initial_value: 0, **args)
+        @count = 0
+      end
+
+      attr_accessor :count
+
+      def update(duration, delta: 0)
+        @mutex.synchronize do
+          @value += duration
+          @count += delta
+        end
+      end
+
+      def reset!
+        @mutex.synchronize do
+          @value = 0
+          @count = 0
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/metrics/set.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Metrics
+    NOOP = NoopMetric.new
+
+    # @api private
+    class Set
+      include Logging
+
+      DISTINCT_LABEL_LIMIT = 1000
+
+      def initialize(config)
+        @config = config
+        @metrics = {}
+        @disabled = false
+        @lock = Mutex.new
+      end
+
+      attr_reader :metrics
+
+      def disable!
+        @disabled = true
+      end
+
+      def disabled?
+        @disabled
+      end
+
+      def counter(key, tags: nil, **args)
+        metric(Counter, key, tags: tags, **args)
+      end
+
+      def gauge(key, tags: nil, **args)
+        metric(Gauge, key, tags: tags, **args)
+      end
+
+      def timer(key, tags: nil, **args)
+        metric(Timer, key, tags: tags, **args)
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def metric(kls, key, tags: nil, **args)
+        key = key_with_tags(key, tags)
+        return metrics[key] if metrics[key]
+
+        @lock.synchronize do
+          return metrics[key] if metrics[key]
+
+          metrics[key] =
+            if metrics.length < DISTINCT_LABEL_LIMIT
+              kls.new(key, tags: tags, **args)
+            else
+              unless @label_limit_logged
+                warn(
+                  'The limit of %d metricsets has been reached, no new ' \
+                   'metricsets will be created.', DISTINCT_LABEL_LIMIT
+                )
+                @label_limit_logged = true
+              end
+
+              NOOP
+            end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      # rubocop:disable Metrics/MethodLength
+      def collect
+        return if disabled?
+
+        @lock.synchronize do
+          metrics.each_with_object({}) do |(key, metric), sets|
+            next unless (value = metric.collect)
+
+            # metrics have a key of name and flat array of key-value pairs
+            #   eg [name, key, value, key, value]
+            # they can be sent in the same metricset but not if they have
+            # differing tags. So, we split the resulting sets by tags first.
+            name, *tags = key
+            sets[tags] ||= Metricset.new
+
+            # then we set the `samples` value for the metricset
+            set = sets[tags]
+            set.samples[name] = value
+
+            # and finally we copy the tags from the Metric to the Metricset
+            set.merge_tags! metric.tags
+          end.values
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def key_with_tags(key, tags)
+        return key unless tags
+
+        tuple = tags.keys.zip(tags.values)
+        tuple.flatten!
+        tuple.unshift(key)
+      end
+    end
+  end
+end

data/lib/elastic_apm/metrics/span_scoped_set.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metrics
+    # @api private
+    class SpanScopedSet < Set
+      def collect
+        super.tap do |sets|
+          return unless sets
+
+          sets.each do |set|
+            move_transaction(set)
+            move_span(set)
+          end
+        end
+      end
+
+      private
+
+      def move_transaction(set)
+        name = set.tags&.delete(:'transaction.name')
+        type = set.tags&.delete(:'transaction.type')
+        return unless name || type
+
+        set.transaction = { name: name, type: type }
+        set.tags = nil if set.tags.empty?
+      end
+
+      def move_span(set)
+        type = set.tags&.delete(:'span.type')
+        subtype = set.tags&.delete(:'span.subtype')
+        return unless type
+
+        set.span = { type: type, subtype: subtype }
+        set.tags = nil if set.tags.empty?
+      end
+    end
+  end
+end

data/lib/elastic_apm/metrics/transaction_set.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metrics
+    # @api private
+    class TransactionSet < SpanScopedSet
+    end
+  end
+end
+
+

data/lib/elastic_apm/metrics/vm_set.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metrics
+    # @api private
+    class VMSet < Set
+      include Logging
+
+      def collect
+        read!
+        super
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def read!
+        return if disabled?
+
+        stat = GC.stat
+
+        gauge(:'ruby.gc.count').value = stat[:count]
+        gauge(:'ruby.threads').value = Thread.list.count
+        gauge(:'ruby.heap.slots.live').value = stat[:heap_live_slots]
+
+        gauge(:'ruby.heap.slots.free').value = stat[:heap_free_slots]
+        gauge(:'ruby.heap.allocations.total').value =
+          stat[:total_allocated_objects]
+
+        return unless GC::Profiler.enabled?
+
+        @total_time ||= 0
+        @total_time += GC::Profiler.total_time
+        GC::Profiler.clear
+        gauge(:'ruby.gc.time').value = @total_time
+      rescue TypeError => e
+        error 'VM metrics encountered error: %s', e
+        debug('Backtrace:') { e.backtrace.join("\n") }
+
+        disable!
+      end
+
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+    end
+  end
+end

data/lib/elastic_apm/metricset.rb

@@ -3,17 +3,44 @@
 module ElasticAPM
   # @api private
   class Metricset
-    def initialize(timestamp: Util.micros, labels: nil, **samples)
+    def initialize(
+      timestamp: Util.micros,
+      tags: nil,
+      transaction: nil,
+      span: nil,
+      **samples
+    )
       @timestamp = timestamp
-      @labels = labels
+      @tags = tags
+      @transaction = transaction
+      @span = span
       @samples = samples
     end
 
-    attr_accessor :timestamp
-    attr_reader :samples, :labels
+    attr_accessor :timestamp, :transaction, :span, :tags
+    attr_reader :samples
+
+    def merge_tags!(tags)
+      return unless tags
+
+      @tags ||= {}
+      @tags.merge! tags
+    end
+
+    def tags?
+      tags&.any?
+    end
 
     def empty?
       samples.empty?
     end
+
+    def inspect
+      "<ElasticAPM::Metricset timestamp:#{timestamp}" \
+        " transaction:#{transaction.inspect}" \
+        " span:#{span.inspect}" \
+        " tags:#{tags.inspect}" \
+        " samples:#{samples.inspect}>"
+    end
   end
 end

data/lib/elastic_apm/normalizers.rb

@@ -12,6 +12,8 @@ module ElasticAPM # :nodoc:
       def self.register(name)
         Normalizers.register(name, self)
       end
+
+      def backtrace(payload); end
     end
 
     def self.register(name, klass)
@@ -54,6 +56,10 @@ module ElasticAPM # :nodoc:
       def normalize(transaction, name, payload)
         self.for(name).normalize(transaction, name, payload)
       end
+
+      def backtrace(name, payload)
+        self.for(name).backtrace(payload)
+      end
     end
   end
 end

data/lib/elastic_apm/normalizers/grape.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+%w[endpoint_run].each do |lib|
+  require "elastic_apm/normalizers/grape/#{lib}"
+end

data/lib/elastic_apm/normalizers/grape/endpoint_run.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Normalizers
+    module Grape
+      # @api private
+      class EndpointRun < Normalizer
+        register 'endpoint_run.grape'
+
+        TYPE = 'app'
+        SUBTYPE = 'resource'
+
+        FRAMEWORK_NAME = 'Grape'
+
+        def normalize(transaction, _name, payload)
+          transaction.name = endpoint(payload[:env])
+
+          if transaction_from_host_app?(transaction)
+            transaction.context.set_service(
+              framework_name: FRAMEWORK_NAME,
+              framework_version: ::Grape::VERSION
+            )
+          end
+
+          [transaction.name, TYPE, SUBTYPE, nil, nil]
+        end
+
+        def backtrace(payload)
+          source_location = payload[:endpoint].source.source_location
+          ["#{source_location[0]}:#{source_location[1]}"]
+        end
+
+        private
+
+        def transaction_from_host_app?(transaction)
+          transaction.config.framework_name != FRAMEWORK_NAME
+        end
+
+        def endpoint(env)
+          route_name = env['api.endpoint']&.routes&.first&.pattern&.origin ||
+            env['REQUEST_PATH']
+          [env['REQUEST_METHOD'], route_name].join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/normalizers/rails/active_record.rb

@@ -11,31 +11,42 @@ module ElasticAPM
 
         TYPE = 'db'
         ACTION = 'sql'
+        SKIP_NAMES = %w[SCHEMA CACHE].freeze
+        UNKNOWN = 'unknown'
 
         def initialize(*args)
           super
 
-          @subtype = lookup_adapter || 'unknown'
           @summarizer = SqlSummarizer.new
+          @adapters = {}
         end
 
         def normalize(_transaction, _name, payload)
-          return :skip if %w[SCHEMA CACHE].include?(payload[:name])
+          return :skip if SKIP_NAMES.include?(payload[:name])
 
           name = summarize(payload[:sql]) || payload[:name]
           context =
             Span::Context.new(db: { statement: payload[:sql], type: 'sql' })
-          [name, TYPE, @subtype, ACTION, context]
+          [name, TYPE, subtype(payload), ACTION, context]
         end
 
         private
 
+        def subtype(payload)
+          cached_adapter_name(
+            payload[:connection] ? payload[:connection].adapter_name :
+              ::ActiveRecord::Base.connection_config[:adapter]
+          )
+        end
+
         def summarize(sql)
           @summarizer.summarize(sql)
         end
 
-        def lookup_adapter
-          ::ActiveRecord::Base.connection.adapter_name.downcase
+        def cached_adapter_name(adapter_name)
+          return UNKNOWN if adapter_name.nil? || adapter_name.empty?
+          @adapters[adapter_name] ||
+            (@adapters[adapter_name] = adapter_name.downcase)
         rescue StandardError
           nil
         end