elastic-apm 3.10.0 → 3.12.1

data/lib/elastic_apm/transaction.rb

@@ -20,6 +20,18 @@
 module ElasticAPM
   # @api private
   class Transaction
+
+    # @api private
+    class Outcome
+      FAILURE = "failure"
+      SUCCESS = "success"
+      UNKNOWN = "unknown"
+
+      def self.from_http_status(code)
+        code.to_i >= 500 ? FAILURE : SUCCESS
+      end
+    end
+
     extend Forwardable
     include ChildDurations::Methods
 
@@ -34,6 +46,7 @@ module ElasticAPM
       name = nil,
       type = nil,
       sampled: true,
+      sample_rate: 1,
       context: nil,
       config:,
       trace_context: nil
@@ -52,13 +65,19 @@ module ElasticAPM
       @default_labels = config.default_labels
 
       @sampled = sampled
+      @sample_rate = sample_rate
 
       @context = context || Context.new # TODO: Lazy generate this?
       if @default_labels
         Util.reverse_merge!(@context.labels, @default_labels)
       end
 
-      @trace_context = trace_context || TraceContext.new(recorded: sampled)
+      unless (@trace_context = trace_context)
+        @trace_context = TraceContext.new(
+          traceparent: TraceContext::Traceparent.new(recorded: sampled),
+          tracestate: TraceContext::Tracestate.new(sample_rate: sampled ? sample_rate : 0)
+        )
+      end
 
       @started_spans = 0
       @dropped_spans = 0
@@ -67,12 +86,26 @@ module ElasticAPM
     end
     # rubocop:enable Metrics/ParameterLists
 
-    attr_accessor :name, :type, :result
+    attr_accessor :name, :type, :result, :outcome
+
+    attr_reader(
+      :breakdown_metrics,
+      :collect_metrics,
+      :context,
+      :dropped_spans,
+      :duration,
+      :framework_name,
+      :notifications,
+      :self_time,
+      :sample_rate,
+      :span_frames_min_duration,
+      :started_spans,
+      :timestamp,
+      :trace_context,
+      :transaction_max_spans 
+    )
 
-    attr_reader :context, :duration, :started_spans, :dropped_spans,
-      :timestamp, :trace_context, :notifications, :self_time,
-      :span_frames_min_duration, :collect_metrics, :breakdown_metrics,
-      :framework_name, :transaction_max_spans
+    alias :collect_metrics? :collect_metrics
 
     def sampled?
       @sampled

data/lib/elastic_apm/transport/connection.rb

@@ -47,6 +47,7 @@ module ElasticAPM
       end
 
       attr_reader :http
+
       def write(str)
         return false if @config.disable_send
 

data/lib/elastic_apm/transport/filters/hash_sanitizer.rb

@@ -17,35 +17,34 @@
 
 # frozen_string_literal: true
 
+require 'elastic_apm/util/deep_dup'
+
 module ElasticAPM
   module Transport
     module Filters
       class HashSanitizer
         FILTERED = '[FILTERED]'
 
-        KEY_FILTERS = [
-          /passw(or)?d/i,
-          /auth/i,
-          /^pw$/,
-          /secret/i,
-          /token/i,
-          /api[-._]?key/i,
-          /session[-._]?id/i,
-          /(set[-_])?cookie/i
-        ].freeze
+        # DEPRECATED: Remove these additions in next major version
+        LEGACY_KEY_FILTERS = [/cookie/i, /auth/i].freeze
 
+        # DEPRECATED: Remove this check in next major version
         VALUE_FILTERS = [
           # (probably) credit card number
           /^\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}$/
         ].freeze
 
-        attr_accessor :key_filters
+        def initialize(key_patterns:)
+          @key_patterns = key_patterns + LEGACY_KEY_FILTERS
+        end
+
+        attr_accessor :key_patterns
 
-        def initialize
-          @key_filters = KEY_FILTERS
+        def strip_from(obj)
+          strip_from!(Util::DeepDup.dup(obj))
         end
 
-        def strip_from!(obj, key_filters = KEY_FILTERS)
+        def strip_from!(obj)
           return unless obj&.is_a?(Hash)
 
           obj.each do |k, v|
@@ -65,7 +64,7 @@ module ElasticAPM
         end
 
         def filter_key?(key)
-          @key_filters.any? { |regex| regex.match(key) }
+          @key_patterns.any? { |regex| regex.match(key) }
         end
 
         def filter_value?(value)

data/lib/elastic_apm/transport/filters/secrets_filter.rb

@@ -26,19 +26,23 @@ module ElasticAPM
       class SecretsFilter
         def initialize(config)
           @config = config
-          @sanitizer = HashSanitizer.new
-          @sanitizer.key_filters += config.custom_key_filters +
-                                     config.sanitize_field_names
+          @sanitizer =
+            HashSanitizer.new(
+              key_patterns: config.custom_key_filters + config.sanitize_field_names
+            )
         end
 
         def call(payload)
-          @sanitizer.strip_from! payload.dig(:transaction, :context, :request, :headers)
-          @sanitizer.strip_from! payload.dig(:transaction, :context, :request, :env)
+          @sanitizer.strip_from! payload.dig(:transaction, :context, :request, :body)
           @sanitizer.strip_from! payload.dig(:transaction, :context, :request, :cookies)
+          @sanitizer.strip_from! payload.dig(:transaction, :context, :request, :env)
+          @sanitizer.strip_from! payload.dig(:transaction, :context, :request, :headers)
           @sanitizer.strip_from! payload.dig(:transaction, :context, :response, :headers)
+          @sanitizer.strip_from! payload.dig(:error, :context, :request, :body)
+          @sanitizer.strip_from! payload.dig(:error, :context, :request, :cookies)
+          @sanitizer.strip_from! payload.dig(:error, :context, :request, :env)
           @sanitizer.strip_from! payload.dig(:error, :context, :request, :headers)
           @sanitizer.strip_from! payload.dig(:error, :context, :response, :headers)
-          @sanitizer.strip_from! payload.dig(:transaction, :context, :request, :body)
 
           payload
         end

data/lib/elastic_apm/transport/serializers.rb

@@ -45,18 +45,20 @@ module ElasticAPM
         def keyword_object(hash)
           return unless hash
 
-          hash.tap do |h|
-            h.each { |k, v| hash[k] = keyword_field(v) }
+          hash.each do |k, v|
+            hash[k] =
+              case v
+              when Hash then keyword_object(v)
+              else keyword_field(v)
+              end
           end
         end
 
         def mixed_object(hash)
           return unless hash
 
-          hash.tap do |h|
-            h.each do |k, v|
-              hash[k] = v.is_a?(String) ? keyword_field(v) : v
-            end
+          hash.each do |k, v|
+            hash[k] = v.is_a?(String) ? keyword_field(v) : v
           end
         end
       end

data/lib/elastic_apm/transport/serializers/metadata_serializer.rb

@@ -23,14 +23,19 @@ module ElasticAPM
       # @api private
       class MetadataSerializer < Serializer
         def build(metadata)
-          {
-            metadata: {
+          base =
+            {
               service: build_service(metadata.service),
               process: build_process(metadata.process),
               system: build_system(metadata.system),
               labels: build_labels(metadata.labels)
             }
-          }
+
+          if (metadata.cloud.provider)
+            base[:cloud] = build_cloud(metadata.cloud)
+          end
+
+          { metadata: base }
         end
 
         private
@@ -83,9 +88,44 @@ module ElasticAPM
           }
         end
 
+        def build_cloud(cloud)
+          strip_nulls!(
+            provider: cloud.provider,
+            account: {
+              id: keyword_field(cloud.account_id),
+              name: keyword_field(cloud.account_name),
+            },
+            availability_zone: keyword_field(cloud.availability_zone),
+            instance: {
+              id: keyword_field(cloud.instance_id),
+              name: keyword_field(cloud.instance_name),
+            },
+            machine: { type: keyword_field(cloud.machine_type) },
+            project: {
+              id: keyword_field(cloud.project_id),
+              name: keyword_field(cloud.project_name),
+            },
+            region: keyword_field(cloud.region)
+          )
+        end
+
         def build_labels(labels)
           keyword_object(labels)
         end
+
+        # A bug in APM Server 7.9 disallows null values in `cloud`
+        def strip_nulls!(hash)
+          hash.keys.each do |key|
+            case value = hash[key]
+            when Hash
+              strip_nulls!(value)
+              hash.delete(key) if value.empty?
+            when nil then hash.delete(key)
+            end
+          end
+
+          hash
+        end
       end
     end
   end

data/lib/elastic_apm/transport/serializers/span_serializer.rb

@@ -42,7 +42,9 @@ module ElasticAPM
               context: context_serializer.build(span.context),
               stacktrace: span.stacktrace.to_a,
               timestamp: span.timestamp,
-              trace_id: span.trace_id
+              trace_id: span.trace_id,
+              sample_rate: span.sample_rate,
+              outcome: keyword_field(span.outcome)
             }
           }
         end

data/lib/elastic_apm/transport/serializers/transaction_serializer.rb

@@ -35,9 +35,11 @@ module ElasticAPM
               name: keyword_field(transaction.name),
               type: keyword_field(transaction.type),
               result: keyword_field(transaction.result.to_s),
+              outcome: keyword_field(transaction.outcome),
               duration: ms(transaction.duration),
               timestamp: transaction.timestamp,
               sampled: transaction.sampled?,
+              sample_rate: transaction.sample_rate,
               context: context_serializer.build(transaction.context),
               span_count: {
                 started: transaction.started_spans,

data/lib/elastic_apm/transport/user_agent.rb

@@ -32,14 +32,14 @@ module ElasticAPM
       private
 
       def build(config)
-        metadata = Metadata.new(config)
+        service = Metadata::ServiceInfo.new(config)
 
         [
           "elastic-apm-ruby/#{VERSION}",
           HTTP::Request::USER_AGENT,
           [
-            metadata.service.runtime.name,
-            metadata.service.runtime.version
+            service.runtime.name,
+            service.runtime.version
           ].join('/')
         ].join(' ')
       end

data/lib/elastic_apm/transport/worker.rb

@@ -53,6 +53,7 @@ module ElasticAPM
       end
 
       attr_reader :queue, :filters, :name, :connection, :serializers
+
       def work_forever
         while (msg = queue.pop)
           case msg

data/lib/elastic_apm/util.rb

@@ -46,6 +46,8 @@ module ElasticAPM
 
     def self.truncate(value, max_length: 1024)
       return unless value
+
+      value = String(value)
       return value if value.length <= max_length
 
       value[0...(max_length - 1)] + '…'

data/lib/elastic_apm/util/deep_dup.rb

@@ -0,0 +1,66 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Util
+    # @api private
+    #
+    # Makes a deep copy of an Array or Hash
+    # NB: Not guaranteed to work well with complex objects, only simple Hash,
+    # Array, String, Number, etc…
+    class DeepDup
+      def initialize(obj)
+        @obj = obj
+      end
+
+      def dup
+        deep_dup(@obj)
+      end
+
+      def self.dup(obj)
+        new(obj).dup
+      end
+
+      private
+
+      def deep_dup(obj)
+        case obj
+        when Hash then hash(obj)
+        when Array then array(obj)
+        else obj.dup
+        end
+      end
+
+      def array(arr)
+        arr.map(&method(:deep_dup))
+      end
+
+      def hash(hsh)
+        result = hsh.dup
+
+        hsh.each_pair do |key, value|
+          result[key] = deep_dup(value)
+        end
+
+        result
+      end
+    end
+  end
+end
+

data/lib/elastic_apm/util/precision_validator.rb

@@ -0,0 +1,46 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Util
+    # @api private
+    # Rounds half away from zero.
+    # If `minimum` is provided, and the value rounds to 0 (but was not zero to
+    # begin with), use the minimum instead.
+    module PrecisionValidator
+      extend self
+
+      def validate(value, precision: 0, minimum: nil)
+        float = Float(value)
+        return nil unless (0.0..1.0).cover?(float)
+        return float if float == 0
+
+        multiplier = Float(10**precision)
+        rounded = (float * multiplier + 0.5).floor / multiplier
+        if rounded == 0 && minimum
+          minimum
+        else
+          rounded
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end