datadog 2.8.0 → 2.39.0

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

@@ -20,15 +20,15 @@ module Datadog
           end
 
           def id
-            @id ||= "#{type}::#{name}::#{tags.join(',')}"
+            @id ||= "#{type}::#{name}::#{tags.join(",")}"
           end
 
           def track(value)
-            raise NotImplementedError, 'method must be implemented in subclasses'
+            raise NotImplementedError, "method must be implemented in subclasses"
           end
 
           def type
-            raise NotImplementedError, 'method must be implemented in subclasses'
+            raise NotImplementedError, "method must be implemented in subclasses"
           end
 
           def to_h
@@ -41,6 +41,18 @@ module Datadog
             }
           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)
@@ -59,7 +71,7 @@ module Datadog
           # @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
+            raise ArgumentError, "interval must be a positive number" if interval.nil? || interval <= 0
 
             super(name, tags: tags, common: common)
 
@@ -71,12 +83,22 @@ module Datadog
             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'
+          TYPE = "count"
 
           def type
             TYPE
@@ -86,9 +108,9 @@ module Datadog
             value = value.to_i
 
             if values.empty?
-              values << [Time.now.to_i, value]
+              values << [Core::Utils::Time.now.to_i, value]
             else
-              values[0][0] = Time.now.to_i
+              values[0][0] = Core::Utils::Time.now.to_i
               values[0][1] += value
             end
             nil
@@ -99,7 +121,7 @@ module Datadog
         # 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'
+          TYPE = "gauge"
 
           def type
             TYPE
@@ -107,9 +129,9 @@ module Datadog
 
           def track(value)
             if values.empty?
-              values << [Time.now.to_i, value]
+              values << [Core::Utils::Time.now.to_i, value]
             else
-              values[0][0] = Time.now.to_i
+              values[0][0] = Core::Utils::Time.now.to_i
               values[0][1] = value
             end
             nil
@@ -119,7 +141,7 @@ module Datadog
         # 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'
+          TYPE = "rate"
 
           def initialize(name, interval:, tags: {}, common: true)
             super
@@ -133,14 +155,14 @@ module Datadog
 
           def track(value = 1.0)
             @value += value
-            @values = [[Time.now.to_i, @value / interval]]
+            @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'
+          TYPE = "distributions"
 
           def type
             TYPE

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'event'
-require_relative 'metric'
+require_relative "event"
+require_relative "metric"
 
 module Datadog
   module Core

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

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'metrics_collection'
+require_relative "metrics_collection"
 
 module Datadog
   module Core
     module Telemetry
       # MetricsManager aggregates and flushes metrics and distributions
+      #
+      # @api private
       class MetricsManager
         attr_reader :enabled
+        attr_reader :collections
 
         def initialize(aggregation_interval:, enabled:)
           @interval = aggregation_interval
@@ -68,6 +71,12 @@ module Datadog
           @enabled = false
         end
 
+        def clear
+          @mutex.synchronize do
+            @collections = {}
+          end
+        end
+
         private
 
         def fetch_or_create_collection(namespace)

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

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../environment/platform'
-require_relative '../utils/hash'
+require_relative "../environment/platform"
+require_relative "../environment/process"
+require_relative "../utils/hash"
 
 module Datadog
   module Core
@@ -9,19 +10,17 @@ module Datadog
       # Module defining methods for collecting metadata for telemetry
       module Request
         class << self
-          using Core::Utils::Hash::Refinement
-
-          def build_payload(event, seq_id)
+          def build_payload(event, seq_id, debug: false)
             hash = {
-              api_version: Http::Ext::API_VERSION,
+              api_version: "v2",
               application: application,
-              debug: false,
+              debug: debug,
               host: host,
               payload: event.payload,
               request_type: event.type,
               runtime_id: Core::Environment::Identity.id,
               seq_id: seq_id,
-              tracer_time: Time.now.to_i,
+              tracer_time: Core::Utils::Time.now.to_i,
             }
             hash.compact!
             hash
@@ -43,7 +42,7 @@ module Datadog
               tracer_version = "#{tracer_version}-ci-#{::Datadog::CI::VERSION::STRING}"
             end
 
-            {
+            app = {
               env: config.env,
               language_name: Core::Environment::Ext::LANG,
               language_version: Core::Environment::Ext::LANG_VERSION,
@@ -53,6 +52,10 @@ module Datadog
               service_version: config.version,
               tracer_version: tracer_version
             }
+
+            tag_process_tags!(app, config)
+
+            app
           end
 
           def host
@@ -64,6 +67,15 @@ module Datadog
               kernel_version: Core::Environment::Platform.kernel_version
             }
           end
+
+          def tag_process_tags!(app, config)
+            return unless config.experimental_propagate_process_tags_enabled
+
+            process_tags = Core::Environment::Process.serialized
+            return if process_tags.empty?
+
+            app[:process_tags] = process_tags
+          end
         end
       end
     end

data/lib/datadog/core/telemetry/transport/http/telemetry.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../../../transport/http/api/endpoint"
+require_relative "../../../transport/http/api/instance"
+require_relative "../../../transport/http/client"
+require_relative "../../../transport/request"
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        module HTTP
+          module Telemetry
+            module API
+              class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+                HEADER_CONTENT_TYPE = "Content-Type"
+
+                attr_reader \
+                  :encoder
+
+                def initialize(path, encoder)
+                  super(:post, path)
+                  @encoder = encoder
+                end
+
+                def call(env, &block)
+                  # Encode body & type
+                  env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+                  env.headers.update(headers(
+                    request_type: env.request.request_type,
+                    api_key: env.request.api_key,
+                  ))
+                  env.body = env.request.parcel.data
+
+                  super
+                end
+
+                def headers(request_type:, api_key:)
+                  {
+                    Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => "1",
+                    # Provided by encoder
+                    # 'Content-Type' => 'application/json',
+                    "DD-Telemetry-API-Version" => "v2",
+                    "DD-Telemetry-Request-Type" => request_type,
+                    "DD-Client-Library-Language" => Core::Environment::Ext::LANG,
+                    "DD-Client-Library-Version" => Core::Environment::Identity.gem_datadog_version_semver2,
+                    "DD-Session-ID" => Core::Environment::Identity.id,
+
+                    # Enable debug mode for telemetry
+                    # 'DD-Telemetry-Debug-Enabled' => 'true',
+                  }.tap do |result|
+                    result["DD-API-KEY"] = api_key unless api_key.nil?
+                    root = Core::Environment::Identity.root_runtime_id
+                    result["DD-Root-Session-ID"] = root if root
+                    parent = Core::Environment::Identity.parent_runtime_id
+                    result["DD-Parent-Session-ID"] = parent if parent
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/transport/http.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../../encoding"
+require_relative "../../transport/http"
+require_relative "telemetry"
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        # Namespace for HTTP transport components
+        module HTTP
+          AGENT_TELEMETRY = Telemetry::API::Endpoint.new(
+            "/telemetry/proxy/api/v2/apmtelemetry",
+            Core::Encoding::JSONEncoder,
+          )
+
+          AGENTLESS_TELEMETRY = Telemetry::API::Endpoint.new(
+            "/api/v2/apmtelemetry",
+            Core::Encoding::JSONEncoder,
+          )
+
+          module_function
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def agentless_telemetry(
+            agent_settings:,
+            logger:,
+            api_key: nil,
+            headers: nil
+          )
+            Core::Transport::HTTP.build(
+              logger: logger,
+              agent_settings: agent_settings,
+              headers: headers
+            ) do |transport|
+              transport.api "agentless_telemetry", AGENTLESS_TELEMETRY
+              # Call block to apply any customization, if provided
+              yield(transport) if block_given?
+            end.to_transport(Core::Telemetry::Transport::Telemetry::Transport).tap do |transport|
+              transport.api_key = api_key
+            end
+          end
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def agent_telemetry(
+            agent_settings:,
+            logger:,
+            headers: nil
+          )
+            Core::Transport::HTTP.build(
+              logger: logger,
+              agent_settings: agent_settings,
+              headers: headers
+            ) do |transport|
+              transport.api "agent_telemetry", AGENT_TELEMETRY
+
+              # Call block to apply any customization, if provided
+              yield(transport) if block_given?
+            end.to_transport(Core::Telemetry::Transport::Telemetry::Transport)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../../transport/parcel"
+require_relative "../../transport/transport"
+require_relative "http/telemetry"
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        module Telemetry
+          class Request < Datadog::Core::Transport::Request
+            attr_reader :request_type
+            attr_reader :api_key
+
+            def initialize(request_type, parcel, api_key)
+              @request_type = request_type
+              super(parcel)
+              @api_key = api_key
+            end
+          end
+
+          class Transport < Core::Transport::Transport
+            attr_accessor :api_key
+
+            def send_telemetry(request_type:, payload:)
+              encoder = Core::Encoding::JSONEncoder
+              parcel = Core::Transport::Parcel.new(
+                encoder.encode(payload),
+                content_type: encoder.content_type,
+              )
+              request = Request.new(request_type, parcel, api_key)
+
+              @client.send_request(:telemetry, request)
+              # Perform no error checking here
+            end
+          end
+        end
+      end
+    end
+  end
+end