elastic-apm 2.8.1 → 2.11.0

data/lib/elastic_apm/config/bytes.rb

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

data/lib/elastic_apm/config/duration.rb

@@ -7,18 +7,16 @@ module ElasticAPM
       MULTIPLIERS = { 'ms' => 0.001, 'm' => 60 }.freeze
       REGEX = /^(-)?(\d+)(m|ms|s)?$/i.freeze
 
-      def initialize(seconds)
-        @seconds = seconds
+      def initialize(default_unit: 's')
+        @default_unit = default_unit
       end
 
-      attr_accessor :seconds
-
-      def self.parse(str, default_unit:)
-        _, negative, amount, unit = REGEX.match(str).to_a
-        unit ||= default_unit
+      def call(str)
+        _, negative, amount, unit = REGEX.match(String(str)).to_a
+        unit ||= @default_unit
         seconds = MULTIPLIERS.fetch(unit.downcase, 1) * amount.to_i
         seconds = 0 - seconds if negative
-        new(seconds)
+        seconds
       end
     end
   end

data/lib/elastic_apm/config/options.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Config
+    # @api private
+    module Options
+      # @api private
+      class Option
+        def initialize(
+          key,
+          value: nil,
+          type: :string,
+          default: nil,
+          converter: nil
+        )
+          @key = key
+          @type = type
+          @default = default
+          @converter = converter
+
+          set(value || default)
+        end
+
+        attr_reader :key, :value, :default, :type
+
+        def set(value)
+          @value = normalize(value)
+        end
+
+        def env_key
+          "ELASTIC_APM_#{key.upcase}"
+        end
+
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        def normalize(val)
+          return unless val
+
+          if @converter
+            return @converter.call(val)
+          end
+
+          case type
+          when :string then val.to_s
+          when :int then val.to_i
+          when :float then val.to_f
+          when :bool then normalize_bool(val)
+          when :list then normalize_list(val)
+          when :dict then normalize_dict(val)
+          else
+            # raise "Unknown options type '#{type.inspect}'"
+            val
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+        def normalize_bool(val)
+          return val unless val.is_a?(String)
+          !%w[0 false].include?(val.strip.downcase)
+        end
+
+        def normalize_list(val)
+          return Array(val) unless val.is_a?(String)
+          val.split(/[ ,]/)
+        end
+
+        def normalize_dict(val)
+          return val unless val.is_a?(String)
+          Hash[val.split(/[&,]/).map { |kv| kv.split('=') }]
+        end
+      end
+
+      # @api private
+      module ClassMethods
+        def schema
+          @schema ||= {}
+        end
+
+        def option(*args)
+          key = args.shift
+          schema[key] = *args
+        end
+      end
+
+      # @api private
+      module InstanceMethods
+        def load_schema
+          Hash[self.class.schema.map do |key, args|
+            [key, Option.new(key, *args)]
+          end]
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def method_missing(name, *value)
+          name_str = name.to_s
+
+          if name_str.end_with?('=')
+            key = name_str[0...-1].to_sym
+            set(key, value.first)
+
+          elsif name_str.end_with?('?')
+            key = name_str[0...-1].to_sym
+            options.key?(key) ? options[key].value : super
+
+          elsif options.key?(name)
+            options.fetch(name).value
+
+          else
+            super
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        def [](key)
+          options[key]
+        end
+        alias :get :[]
+
+        def set(key, value)
+          options.fetch(key.to_sym).set(value)
+        rescue KeyError
+          warn format("Unknown option '%s'", key)
+          nil
+        end
+      end
+
+      def self.extended(kls)
+        kls.instance_eval { extend ClassMethods }
+        kls.class_eval { include InstanceMethods }
+      end
+    end
+  end
+end

data/lib/elastic_apm/config/regexp_list.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Config
+    # @api private
+    class RegexpList
+      def call(value)
+        value = value.is_a?(String) ? value.split(',') : Array(value)
+        value.map(&Regexp.method(:new))
+      end
+    end
+  end
+end

data/lib/elastic_apm/context_builder.rb

@@ -38,6 +38,8 @@ module ElasticAPM
       request.headers = headers if config.capture_headers?
       request.env = env if config.capture_env?
 
+      request.cookies = req.cookies
+
       context
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize

data/lib/elastic_apm/error/exception.rb

@@ -11,6 +11,7 @@ module ElasticAPM
           "#{exception.class}: #{exception.message}"
         @type = exception.class.to_s
         @module = format_module exception
+        @cause = exception.cause && Exception.new(exception.cause)
 
         attrs.each do |key, val|
           send(:"#{key}=", val)
@@ -24,7 +25,8 @@ module ElasticAPM
         :message,
         :module,
         :stacktrace,
-        :type
+        :type,
+        :cause
       )
 
       private

data/lib/elastic_apm/error_builder.rb

@@ -52,12 +52,15 @@ module ElasticAPM
       error.culprit = stacktrace.frames.first.function
     end
 
-    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def add_current_transaction_fields(error, transaction)
       return unless transaction
 
       error.transaction_id = transaction.id
-      error.transaction = { sampled: transaction.sampled? }
+      error.transaction = {
+        sampled: transaction.sampled?,
+        type: transaction.type
+      }
       error.trace_id = transaction.trace_id
       error.parent_id = ElasticAPM.current_span&.id || transaction.id
 
@@ -66,6 +69,6 @@ module ElasticAPM
       Util.reverse_merge!(error.context.tags, transaction.context.tags)
       Util.reverse_merge!(error.context.custom, transaction.context.custom)
     end
-    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
   end
 end

data/lib/elastic_apm/instrumenter.rb

@@ -134,9 +134,12 @@ module ElasticAPM
 
     # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
     # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/ParameterLists
     def start_span(
       name,
       type = nil,
+      subtype: nil,
+      action: nil,
       backtrace: nil,
       context: nil,
       trace_context: nil
@@ -155,6 +158,8 @@ module ElasticAPM
 
       span = Span.new(
         name: name,
+        subtype: subtype,
+        action: action,
         transaction_id: transaction.id,
         trace_context: trace_context || parent.trace_context.child,
         type: type,
@@ -170,6 +175,7 @@ module ElasticAPM
 
       span.start
     end
+    # rubocop:enable Metrics/ParameterLists
     # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
     # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 

data/lib/elastic_apm/metadata.rb

@@ -7,9 +7,10 @@ module ElasticAPM
       @service = ServiceInfo.new(config)
       @process = ProcessInfo.new(config)
       @system = SystemInfo.new(config)
+      @labels = config.global_labels
     end
 
-    attr_reader :service, :process, :system
+    attr_reader :service, :process, :system, :labels
   end
 end
 

data/lib/elastic_apm/metrics.rb

@@ -24,7 +24,7 @@ module ElasticAPM
       def initialize(config, tags: nil, &block)
         @config = config
         @tags = tags
-        @samplers = [CpuMem].map do |kls|
+        @samplers = [CpuMem, VM].map do |kls|
           debug "Adding metrics collector '#{kls}'"
           kls.new(config)
         end
@@ -95,3 +95,4 @@ module ElasticAPM
 end
 
 require 'elastic_apm/metrics/cpu_mem'
+require 'elastic_apm/metrics/vm'

data/lib/elastic_apm/metrics/vm.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Metrics
+    # @api private
+    class VM
+      include Logging
+
+      def initialize(config)
+        @config = config
+        @total_time = 0
+        @disabled = false
+      end
+
+      attr_reader :config
+      attr_writer :disabled
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def collect
+        return if disabled?
+
+        stat = GC.stat
+        thread_count = Thread.list.count
+
+        sample = {
+          'ruby.gc.count': stat[:count],
+          'ruby.threads': thread_count
+        }
+
+        (live_slots = stat[:heap_live_slots]) &&
+          sample[:'ruby.heap.slots.live'] = live_slots
+        (heap_slots = stat[:heap_free_slots]) &&
+          sample[:'ruby.heap.slots.free'] = heap_slots
+        (allocated = stat[:total_allocated_objects]) &&
+          sample[:'ruby.heap.allocations.total'] = allocated
+
+        return sample unless GC::Profiler.enabled?
+
+        @total_time += GC::Profiler.total_time
+        GC::Profiler.clear
+        sample[:'ruby.gc.time'] = @total_time
+
+        sample
+      rescue TypeError => e
+        error 'VM metrics encountered error: %s', e
+        debug('Backtrace:') { e.backtrace.join("\n") }
+
+        @disabled = true
+        nil
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      def disabled?
+        @disabled
+      end
+    end
+  end
+end

data/lib/elastic_apm/normalizers/action_controller.rb

@@ -6,11 +6,14 @@ module ElasticAPM
       # @api private
       class ProcessActionNormalizer < Normalizer
         register 'process_action.action_controller'
-        TYPE = 'app.controller.action'
+
+        TYPE = 'app'
+        SUBTYPE = 'controller'
+        ACTION = 'action'
 
         def normalize(transaction, _name, payload)
           transaction.name = endpoint(payload)
-          [transaction.name, TYPE, nil]
+          [transaction.name, TYPE, SUBTYPE, ACTION, nil]
         end
 
         private

data/lib/elastic_apm/normalizers/action_mailer.rb

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

data/lib/elastic_apm/normalizers/action_view.rb

@@ -7,8 +7,8 @@ module ElasticAPM
       class RenderNormalizer < Normalizer
         private
 
-        def normalize_render(payload, type)
-          [path_for(payload[:identifier]), type, nil]
+        def normalize_render(payload, type, subtype, action)
+          [path_for(payload[:identifier]), type, subtype, action, nil]
         end
 
         def path_for(path)
@@ -19,7 +19,7 @@ module ElasticAPM
         end
 
         def view_path(path)
-          root = @config.view_paths.find { |vp| path.start_with?(vp) }
+          root = @config.__view_paths.find { |vp| path.start_with?(vp) }
           return unless root
 
           strip_root(root, path)
@@ -41,30 +41,35 @@ module ElasticAPM
       # @api private
       class RenderTemplateNormalizer < RenderNormalizer
         register 'render_template.action_view'
-        TYPE = 'template.view'
+        TYPE = 'template'
+        SUBTYPE = 'view'
 
         def normalize(_transaction, _name, payload)
-          normalize_render(payload, TYPE)
+          normalize_render(payload, TYPE, SUBTYPE, nil)
         end
       end
 
       # @api private
       class RenderPartialNormalizer < RenderNormalizer
         register 'render_partial.action_view'
-        TYPE = 'template.view.partial'
+        TYPE = 'template'
+        SUBTYPE = 'view'
+        ACTION = 'partial'
 
         def normalize(_transaction, _name, payload)
-          normalize_render(payload, TYPE)
+          normalize_render(payload, TYPE, SUBTYPE, ACTION)
         end
       end
 
       # @api private
       class RenderCollectionNormalizer < RenderNormalizer
         register 'render_collection.action_view'
-        TYPE = 'template.view.collection'
+        TYPE = 'template'
+        SUBTYPE = 'view'
+        ACTION = 'collection'
 
         def normalize(_transaction, _name, payload)
-          normalize_render(payload, TYPE)
+          normalize_render(payload, TYPE, SUBTYPE, ACTION)
         end
       end
     end