cw-datadog 2.23.0.2

data/lib/datadog/core/telemetry/event/log.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'logs' event.
+        # Logs with the same content are deduplicated at flush time.
+        class Log < Base
+          LEVELS = {
+            error: 'ERROR',
+            warn: 'WARN',
+          }.freeze
+
+          LEVELS_STRING = LEVELS.values.freeze
+
+          attr_reader :message, :level, :stack_trace, :count
+
+          def type
+            'logs'
+          end
+
+          # @param message [String] the log message
+          # @param level [Symbol, String] the log level. Either :error, :warn, 'ERROR', or 'WARN'.
+          # @param stack_trace [String, nil] the stack trace
+          # @param count [Integer] the number of times the log was emitted. Used for deduplication.
+          def initialize(message:, level:, stack_trace: nil, count: 1)
+            super()
+            @message = message
+            @stack_trace = stack_trace
+
+            if level.is_a?(String) && LEVELS_STRING.include?(level)
+              # String level is used during object copy for deduplication
+              @level = level
+            elsif level.is_a?(Symbol)
+              # Symbol level is used by the regular log emitter user
+              @level = LEVELS.fetch(level) { |k| raise ArgumentError, "Invalid log level :#{k}" }
+            else
+              raise ArgumentError, "Invalid log level #{level}"
+            end
+
+            @count = count
+          end
+
+          def payload
+            {
+              logs: [
+                {
+                  message: @message,
+                  level: @level,
+                  stack_trace: @stack_trace,
+                  count: @count,
+                }.compact
+              ]
+            }
+          end
+
+          # override equality to allow for deduplication
+          def ==(other)
+            other.is_a?(Log) &&
+              other.message == @message &&
+              other.level == @level && other.stack_trace == @stack_trace && other.count == @count
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            [self.class, @message, @level, @stack_trace, @count].hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event/message_batch.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'message-batch' event.
+        class MessageBatch < Base
+          attr_reader :events
+
+          def type
+            'message-batch'
+          end
+
+          def initialize(events)
+            super()
+            @events = events
+          end
+
+          def payload
+            @events.map do |event|
+              {
+                request_type: event.type,
+                payload: event.payload,
+              }
+            end
+          end
+
+          def ==(other)
+            other.is_a?(MessageBatch) && other.events == @events
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            [self.class, @events].hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event/synth_app_client_configuration_change.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # app-client-configuration-change event emitted instead of
+        # app-started event for telemetry startups other than the initial
+        # one in a process.
+        #
+        # dd-trace-rb generally creates a new component tree whenever
+        # the tracer is reconfigured via Datadog.configure (with some
+        # components potentially reused, if their configuration has not
+        # changed). Telemetry system tests on the other hand expect there
+        # to be one "tracer" per process, and do not permit multiple
+        # app-started events to be emitted.
+        #
+        # To resolve this conflict, we replace second and onward app-started
+        # events with app-client-configuration-change events.
+        # To avoid diffing configuration, we send all parameters that are
+        # sent in app-started event.
+        #
+        # It's a "quick fix" on top of a not-so-quick fix that omitted
+        # second and subsequent app-started (and app-closing) events in the
+        # first place, and only works with the existing hackery of app-started
+        # and app-closing events.
+        class SynthAppClientConfigurationChange < AppStarted
+          def type
+            'app-client-configuration-change'
+          end
+
+          def payload
+            {
+              configuration: configuration,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../utils/forking'
+require_relative '../utils/sequence'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Collection of telemetry events.
+      #
+      # @api private
+      module Event
+        extend Core::Utils::Forking
+
+        # returns sequence that increments every time the configuration changes
+        def self.configuration_sequence
+          after_fork! { @sequence = Datadog::Core::Utils::Sequence.new(1) }
+          @sequence ||= Datadog::Core::Utils::Sequence.new(1)
+        end
+      end
+    end
+  end
+end
+
+require_relative 'event/base'
+require_relative 'event/app_client_configuration_change'
+require_relative 'event/app_closing'
+require_relative 'event/app_dependencies_loaded'
+require_relative 'event/app_endpoints_loaded'
+require_relative 'event/app_heartbeat'
+require_relative 'event/app_integrations_change'
+require_relative 'event/app_started'
+require_relative 'event/synth_app_client_configuration_change'
+require_relative 'event/generate_metrics'
+require_relative 'event/distributions'
+require_relative 'event/log'
+require_relative 'event/message_batch'

data/lib/datadog/core/telemetry/ext.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module Ext
+        ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'
+        ENV_METRICS_ENABLED = 'DD_TELEMETRY_METRICS_ENABLED'
+        ENV_HEARTBEAT_INTERVAL = 'DD_TELEMETRY_HEARTBEAT_INTERVAL'
+        ENV_METRICS_AGGREGATION_INTERVAL = 'DD_TELEMETRY_METRICS_AGGREGATION_INTERVAL'
+        ENV_DEPENDENCY_COLLECTION = 'DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED'
+        ENV_INSTALL_ID = 'DD_INSTRUMENTATION_INSTALL_ID'
+        ENV_INSTALL_TYPE = 'DD_INSTRUMENTATION_INSTALL_TYPE'
+        ENV_INSTALL_TIME = 'DD_INSTRUMENTATION_INSTALL_TIME'
+        ENV_AGENTLESS_URL_OVERRIDE = 'DD_TELEMETRY_AGENTLESS_URL'
+        ENV_LOG_COLLECTION = 'DD_TELEMETRY_LOG_COLLECTION_ENABLED'
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/http/adapters/net.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# datadog-ci-rb versions 1.15.0 and lower require this file and guard
+# the require with a rescue of StandardError. Unfortunately LoadError,
+# which would be raised if the file is missing, is not a subclass of
+# StandardError and thus would not be caught by the rescue.
+# We provide this file with a dummy class in it to avoid exceptions
+# in datadog-ci-rb until version 2.0 is released.
+#
+# Note that datadog-ci-rb patches telemetry transport to be "real" even when
+# webmock is used; this patching won't work with datadog-ci-rb versions
+# 1.15.0 and older and dd-trace-rb 2.16.0 and newer. There will be no
+# errors/exceptions reported but telemetry events will not be sent.
+
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        module Adapters
+          class Net # rubocop:disable Lint/EmptyClass
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/logger.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      # === INTERNAL USAGE ONLY ===
+      #
+      # Report telemetry logs via delegating to the telemetry component instance via mutex.
+      #
+      # IMPORTANT: Invoking this method during the lifecycle of component initialization will
+      # be no-op instead.
+      #
+      # For developer using this module:
+      #   read: lib/datadog/core/telemetry/logging.rb
+      module Logger
+        class << self
+          def report(exception, level: :error, description: nil)
+            instance&.report(exception, level: level, description: description)
+          end
+
+          def error(description)
+            instance&.error(description)
+          end
+
+          private
+
+          def instance
+            # Component initialization uses a mutex to avoid having concurrent initialization.
+            # Trying to access the telemetry component during initialization (specifically:
+            # from the thread that's actually doing the initialization) would cause a deadlock,
+            # since accessing the components would try to recursively lock the mutex.
+            #
+            # To work around this, we use allow_initialization: false to avoid triggering this issue.
+            #
+            # The downside is: this leaves us unable to report telemetry during component initialization.
+            components = Datadog.send(:components, allow_initialization: false)
+            telemetry = components&.telemetry
+
+            if telemetry
+              telemetry
+            else
+              Datadog.logger.warn(
+                'Failed to send telemetry before components initialization or within components lifecycle'
+              )
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/logging.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'event'
+
+require 'pathname'
+
+module Datadog
+  module Core
+    module Telemetry
+      # === INTERNAL USAGE ONLY ===
+      #
+      # Logging interface for sending telemetry logs... so we can fix them.
+      #
+      # For developer using this module:
+      # - MUST NOT provide any sensitive information (PII)
+      # - SHOULD reduce the data cardinality for batching/aggregation
+      #
+      # Before using it, ask yourself:
+      # - Do we need to know about this (ie. internal error or client error)?
+      # - How severe/critical is this error? (ie. error, warning, fatal)
+      # - What information needed to make it actionable?
+      #
+      module Logging
+        # Extract datadog stack trace from the exception
+        module DatadogStackTrace
+          GEM_ROOT = Pathname.new("#{__dir__}/../../../..").cleanpath.to_s
+
+          def self.from(exception)
+            backtrace = exception.backtrace
+
+            return unless backtrace
+            return if backtrace.empty?
+
+            # vendored deps
+            vendored_deps = Gem.path.any? { |p| p.start_with?(GEM_ROOT) }
+
+            backtrace.map do |line|
+              if !vendored_deps && line.start_with?(GEM_ROOT) ||
+                  vendored_deps && line.start_with?(GEM_ROOT) && Gem.path.none? { |p| line.start_with?(p) }
+                line[GEM_ROOT.length..-1] || ''
+              else
+                'REDACTED'
+              end
+            end.join("\n")
+          end
+        end
+
+        def report(exception, level: :error, description: nil)
+          # Anonymous exceptions to be logged as <Class:0x00007f8b1c0b3b40>
+          message = +"#{exception.class.name || exception.class.inspect}" # standard:disable Style/RedundantInterpolation
+
+          message << ": #{description}" if description
+
+          event = Event::Log.new(
+            message: message,
+            level: level,
+            stack_trace: DatadogStackTrace.from(exception)
+          )
+
+          log!(event)
+        end
+
+        def error(description)
+          event = Event::Log.new(message: description, level: :error)
+
+          log!(event)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/metric.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      # Telemetry metrics data model (internal Datadog metrics for client libraries)
+      module Metric
+        # Base class for all metric types
+        class Base
+          attr_reader :name, :tags, :values, :common
+
+          # @param name [String] metric name
+          # @param tags [Array<String>|Hash{String=>String}] metric tags as hash or array of "tag:val" strings
+          # @param common [Boolean] true if the metric is common for all languages, false for Ruby-specific metric
+          def initialize(name, tags: {}, common: true)
+            @name = name
+            @values = []
+            @tags = tags_to_array(tags)
+            @common = common
+          end
+
+          def id
+            @id ||= "#{type}::#{name}::#{tags.join(",")}"
+          end
+
+          def track(value)
+            raise NotImplementedError, 'method must be implemented in subclasses'
+          end
+
+          def type
+            raise NotImplementedError, 'method must be implemented in subclasses'
+          end
+
+          def to_h
+            {
+              metric: name,
+              points: values,
+              type: type,
+              tags: tags,
+              common: common
+            }
+          end
+
+          def ==(other)
+            other.is_a?(self.class) &&
+              name == other.name &&
+              values == other.values && tags == other.tags && common == other.common && type == other.type
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            [self.class, name, values, tags, common, type].hash
+          end
+
+          private
+
+          def tags_to_array(tags)
+            return tags if tags.is_a?(Array)
+
+            tags.map { |k, v| "#{k}:#{v}" }
+          end
+        end
+
+        # Base class for metrics that require aggregation interval
+        class IntervalMetric < Base
+          attr_reader :interval
+
+          # @param name [String] metric name
+          # @param tags [Array<String>|Hash{String=>String}] metric tags as hash of array of "tag:val" strings
+          # @param common [Boolean] true if the metric is common for all languages, false for Ruby-specific metric
+          # @param interval [Integer] metrics aggregation interval in seconds
+          def initialize(name, interval:, tags: {}, common: true)
+            raise ArgumentError, 'interval must be a positive number' if interval.nil? || interval <= 0
+
+            super(name, tags: tags, common: common)
+
+            @interval = interval
+          end
+
+          def to_h
+            res = super
+            res[:interval] = interval
+            res
+          end
+
+          def ==(other)
+            super && interval == other.interval
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            [super, interval].hash
+          end
+        end
+
+        # Count metric adds up all the submitted values in a time interval. This would be suitable for a
+        # metric tracking the number of website hits, for instance.
+        class Count < Base
+          TYPE = 'count'
+
+          def type
+            TYPE
+          end
+
+          def track(value)
+            value = value.to_i
+
+            if values.empty?
+              values << [Core::Utils::Time.now.to_i, value]
+            else
+              values[0][0] = Core::Utils::Time.now.to_i
+              values[0][1] += value
+            end
+            nil
+          end
+        end
+
+        # A gauge type takes the last value reported during the interval. This type would make sense for tracking RAM or
+        # CPU usage, where taking the last value provides a representative picture of the host’s behavior during the time
+        # interval.
+        class Gauge < IntervalMetric
+          TYPE = 'gauge'
+
+          def type
+            TYPE
+          end
+
+          def track(value)
+            if values.empty?
+              values << [Core::Utils::Time.now.to_i, value]
+            else
+              values[0][0] = Core::Utils::Time.now.to_i
+              values[0][1] = value
+            end
+            nil
+          end
+        end
+
+        # The rate type takes the count and divides it by the length of the time interval. This is useful if you’re
+        # interested in the number of hits per second.
+        class Rate < IntervalMetric
+          TYPE = 'rate'
+
+          def initialize(name, interval:, tags: {}, common: true)
+            super
+
+            @value = 0.0
+          end
+
+          def type
+            TYPE
+          end
+
+          def track(value = 1.0)
+            @value += value
+            @values = [[Core::Utils::Time.now.to_i, @value / interval]]
+            nil
+          end
+        end
+
+        # Distribution metric represents the global statistical distribution of a set of values.
+        class Distribution < Base
+          TYPE = 'distributions'
+
+          def type
+            TYPE
+          end
+
+          def track(value)
+            values << value
+            nil
+          end
+
+          # distribution metric data does not have type field
+          def to_h
+            {
+              metric: name,
+              points: values,
+              tags: tags,
+              common: common
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/metrics_collection.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'event'
+require_relative 'metric'
+
+module Datadog
+  module Core
+    module Telemetry
+      # MetricsCollection is a thread-safe collection of metrics per namespace
+      class MetricsCollection
+        attr_reader :namespace, :interval
+
+        def initialize(namespace, aggregation_interval:)
+          @namespace = namespace
+          @interval = aggregation_interval
+
+          @mutex = Mutex.new
+
+          @metrics = {}
+          @distributions = {}
+        end
+
+        def inc(metric_name, value, tags: {}, common: true)
+          metric = Metric::Count.new(metric_name, tags: tags, common: common)
+          fetch_or_add_metric(metric, value)
+        end
+
+        def dec(metric_name, value, tags: {}, common: true)
+          metric = Metric::Count.new(metric_name, tags: tags, common: common)
+          fetch_or_add_metric(metric, -value)
+        end
+
+        def gauge(metric_name, value, tags: {}, common: true)
+          metric = Metric::Gauge.new(metric_name, tags: tags, common: common, interval: @interval)
+          fetch_or_add_metric(metric, value)
+        end
+
+        def rate(metric_name, value, tags: {}, common: true)
+          metric = Metric::Rate.new(metric_name, tags: tags, common: common, interval: @interval)
+          fetch_or_add_metric(metric, value)
+        end
+
+        def distribution(metric_name, value, tags: {}, common: true)
+          metric = Metric::Distribution.new(metric_name, tags: tags, common: common)
+          fetch_or_add_distribution(metric, value)
+        end
+
+        def flush!
+          @mutex.synchronize do
+            events = []
+            events << Event::GenerateMetrics.new(@namespace, @metrics.values) if @metrics.any?
+            events << Event::Distributions.new(@namespace, @distributions.values) if @distributions.any?
+
+            @metrics = {}
+            @distributions = {}
+
+            events
+          end
+        end
+
+        private
+
+        def fetch_or_add_metric(metric, value)
+          @mutex.synchronize do
+            m = (@metrics[metric.id] ||= metric)
+            m.track(value)
+          end
+          nil
+        end
+
+        def fetch_or_add_distribution(metric, value)
+          @mutex.synchronize do
+            m = (@distributions[metric.id] ||= metric)
+            m.track(value)
+          end
+          nil
+        end
+      end
+    end
+  end
+end