cw-datadog 2.23.0.2

data/lib/datadog/tracing/transport/http/client.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'statistics'
+require_relative '../../../core/transport/http/env'
+require_relative '../../../core/transport/http/response'
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        # Routes, encodes, and sends tracer data to the trace agent via HTTP.
+        class Client
+          include Datadog::Tracing::Transport::HTTP::Statistics
+
+          attr_reader :api, :logger
+
+          def initialize(api, logger: Datadog.logger)
+            @api = api
+            @logger = logger
+          end
+
+          def send_request(request, &block)
+            # Build request into env
+            env = build_env(request)
+
+            # Get responses from API
+            response = yield(api, env)
+
+            # Update statistics
+            update_stats_from_response!(response)
+
+            response
+          rescue => e
+            message =
+              "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
+                "Location: #{Array(e.backtrace).first}"
+
+            # Log error
+            if stats.consecutive_errors > 0
+              logger.debug(message)
+            else
+              # Not to report telemetry logs
+              logger.error(message)
+            end
+
+            # Update statistics
+            update_stats_from_exception!(e)
+
+            Datadog::Core::Transport::InternalErrorResponse.new(e)
+          end
+
+          def build_env(request)
+            Datadog::Core::Transport::HTTP::Env.new(request)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/http/statistics.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../statistics'
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        # Tracks statistics for HTTP transports
+        module Statistics
+          def self.included(base)
+            base.include(Datadog::Tracing::Transport::Statistics)
+            base.include(InstanceMethods)
+          end
+
+          # Instance methods for HTTP statistics
+          module InstanceMethods
+            # Decorate metrics for HTTP responses
+            def metrics_for_response(response)
+              super.tap do |metrics|
+                # Add status code tag to api.responses metric
+                if metrics.key?(:api_responses)
+                  (metrics[:api_responses].options[:tags] ||= []).tap do |tags|
+                    tags << metrics_tag_value(response.code)
+                  end
+                end
+              end
+            end
+
+            private
+
+            # The most common status code on a healthy tracer
+            STATUS_CODE_200 = 'status_code:200'
+
+            def metrics_tag_value(status_code)
+              if status_code == 200
+                STATUS_CODE_200 # DEV Saves string concatenation/creation for common case
+              else
+                "status_code:#{status_code}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/http/traces.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative '../traces'
+require_relative 'client'
+require_relative '../../../core/transport/http/response'
+require_relative '../../../core/transport/http/api/endpoint'
+require_relative '../../../core/transport/http/api/spec'
+require_relative '../../../core/transport/http/api/instance'
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        # HTTP transport behavior for traces
+        module Traces
+          # Response from HTTP transport for traces
+          class Response
+            include Datadog::Core::Transport::HTTP::Response
+            include Datadog::Tracing::Transport::Traces::Response
+
+            def initialize(http_response, options = {})
+              super(http_response)
+              @service_rates = options.fetch(:service_rates, nil)
+              @trace_count = options.fetch(:trace_count, 0)
+            end
+          end
+
+          # Extensions for HTTP client
+          module Client
+            def send_traces_payload(request)
+              send_request(request) do |api, env|
+                api.send_traces(env)
+              end
+            end
+          end
+
+          module API
+            # HTTP API Spec
+            class Spec < Core::Transport::HTTP::API::Spec
+              attr_accessor :traces
+
+              def send_traces(env, &block)
+                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('traces', self) if traces.nil?
+
+                traces.call(env, &block)
+              end
+
+              def encoder
+                traces.encoder
+              end
+            end
+
+            # HTTP API Instance
+            class Instance < Core::Transport::HTTP::API::Instance
+              def send_traces(env)
+                unless spec.is_a?(Traces::API::Spec)
+                  raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new(
+                    'traces', self
+                  )
+                end
+
+                spec.send_traces(env) do |request_env|
+                  call(request_env)
+                end
+              end
+            end
+
+            # Endpoint for submitting trace data
+            class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+              HEADER_CONTENT_TYPE = 'Content-Type'
+              HEADER_TRACE_COUNT = 'X-Datadog-Trace-Count'
+              SERVICE_RATE_KEY = 'rate_by_service'
+
+              attr_reader \
+                :encoder
+
+              def initialize(path, encoder, options = {})
+                super(:post, path)
+                @encoder = encoder
+                @service_rates = options.fetch(:service_rates, false)
+              end
+
+              def service_rates?
+                @service_rates == true
+              end
+
+              def call(env, &block)
+                # Check Cloudwise probe state - if suspended, don't send traces
+                if cloudwise_probe_suspended?
+                  Datadog.logger.debug { 'Cloudwise: Probe suspended, skipping trace submission' }
+                  # Return a mock successful response to avoid errors
+                  return build_mock_response(env)
+                end
+
+                # Add trace count header
+                env.headers[HEADER_TRACE_COUNT] = env.request.parcel.trace_count.to_s
+
+                # Add routing key header
+                env.headers['routingKey'] = 'rubyTopic'
+
+                # Encode body & type
+                env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+                env.body = env.request.parcel.data
+
+                # Query for response
+                http_response = super
+
+                # Process the response
+                response_options = {trace_count: env.request.parcel.trace_count}.tap do |options|
+                  # Parse service rates, if configured to do so.
+                  if service_rates? && !http_response.payload.to_s.empty?
+                    body = JSON.parse(http_response.payload)
+                    options[:service_rates] = body[SERVICE_RATE_KEY] if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
+                  end
+                end
+
+                # Build and return a trace response
+                Traces::Response.new(http_response, response_options)
+              end
+
+              private
+
+              def cloudwise_probe_suspended?
+                # Check if Cloudwise component exists and probe is suspended
+                return false unless defined?(Datadog.components)
+                return false unless Datadog.components.respond_to?(:cloudwise)
+                
+                cloudwise = Datadog.components.cloudwise
+                return false unless cloudwise&.enabled?
+                
+                cloudwise.probe_state.suspended?
+              rescue => e
+                # If any error occurs, don't block trace submission
+                Datadog.logger.debug { "Cloudwise probe check error: #{e.message}" }
+                false
+              end
+
+              def build_mock_response(env)
+                # Create a mock HTTP response
+                mock_http_response = Struct.new(:code, :payload).new(200, '{}')
+                response_options = { trace_count: env.request.parcel.trace_count }
+                Traces::Response.new(mock_http_response, response_options)
+              end
+            end
+          end
+
+          # Add traces behavior to transport components
+          HTTP::Client.include(Traces::Client)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/http.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../core/environment/container'
+require_relative '../../core/environment/ext'
+require_relative '../../core/transport/ext'
+require_relative '../../core/transport/http'
+require_relative 'http/api'
+require_relative '../../../datadog/version'
+
+module Datadog
+  module Tracing
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        module_function
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def default(
+          agent_settings:,
+          logger: Datadog.logger,
+          api_version: nil,
+          headers: nil
+        )
+          Core::Transport::HTTP.build(
+            api_instance_class: Traces::API::Instance,
+            agent_settings: agent_settings,
+            logger: logger,
+            api_version: api_version,
+            headers: headers
+          ) do |transport|
+            apis = API.defaults
+
+            transport.api API::V4, apis[API::V4], fallback: API::V3, default: true
+            transport.api API::V3, apis[API::V3]
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end.to_transport(Transport::Traces::Transport)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io/client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../statistics'
+require_relative 'response'
+
+module Datadog
+  module Tracing
+    module Transport
+      module IO
+        # Encodes and writes tracer data to IO
+        class Client
+          include Transport::Statistics
+
+          attr_reader \
+            :encoder,
+            :out
+
+          def initialize(out, encoder, options = {})
+            @out = out
+            @encoder = encoder
+
+            @request_block = options.fetch(:request, method(:send_default_request))
+            @encode_block = options.fetch(:encode, method(:encode_data))
+            @write_block = options.fetch(:write, method(:write_data))
+            @response_block = options.fetch(:response, method(:build_response))
+          end
+
+          def send_request(request)
+            # Write data to IO
+            # If block is given, allow it to handle writing
+            # Otherwise do a standard encode/write/response.
+            response = if block_given?
+              yield(out, request)
+            else
+              @request_block.call(out, request)
+            end
+
+            # Update statistics
+            update_stats_from_response!(response)
+
+            # Return response
+            response
+          rescue => e
+            message =
+              "Internal error during IO transport request. Cause: #{e.class.name} #{e.message} " \
+                "Location: #{Array(e.backtrace).first}"
+
+            # Log error
+            if stats.consecutive_errors > 0
+              Datadog.logger.debug(message)
+            else
+              # Not to report telemetry logs
+              Datadog.logger.error(message)
+            end
+
+            # Update statistics
+            update_stats_from_exception!(e)
+
+            InternalErrorResponse.new(e)
+          end
+
+          def encode_data(encoder, request)
+            request.parcel.encode_with(encoder)
+          end
+
+          def write_data(out, data)
+            out.puts(data)
+          end
+
+          def build_response(_request, _data, result)
+            IO::Response.new(result)
+          end
+
+          private
+
+          def send_default_request(out, request)
+            # Encode data
+            data = @encode_block.call(encoder, request)
+
+            # Write to IO
+            result = @write_block.call(out, data)
+
+            # Generate a response
+            @response_block.call(request, data, result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io/response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/response'
+
+module Datadog
+  module Tracing
+    module Transport
+      module IO
+        # Response from HTTP transport for traces
+        class Response
+          include Datadog::Core::Transport::Response
+
+          attr_reader \
+            :result
+
+          def initialize(result)
+            @result = result
+          end
+
+          def ok?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io/traces.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative '../../transport/traces'
+require_relative '../../../core/transport/parcel'
+require_relative 'response'
+require_relative 'client'
+
+module Datadog
+  module Tracing
+    module Transport
+      module IO
+        # IO transport behavior for traces
+        module Traces
+          # Response from HTTP transport for traces
+          class Response < IO::Response
+            include Transport::Traces::Response
+
+            def initialize(result, trace_count = 1)
+              super(result)
+              @trace_count = trace_count
+            end
+          end
+
+          # Extensions for HTTP client
+          module Client
+            def send_traces(traces)
+              # Build a request
+              req = Transport::Traces::Request.new(Parcel.new(traces))
+
+              [send_request(req) do |out, request|
+                # Encode trace data
+                data = encode_data(encoder, request)
+
+                # Write to IO
+                result = if block_given?
+                  yield(out, data)
+                else
+                  write_data(out, data)
+                end
+
+                # Generate response
+                Traces::Response.new(result)
+              end]
+            end
+          end
+
+          # Encoder for IO-specific trace encoding
+          # API compliant when used with {JSONEncoder}.
+          module Encoder
+            ENCODED_IDS = [
+              :trace_id,
+              :span_id,
+              :parent_id
+            ].freeze
+
+            # Encodes a list of traces
+            def encode_traces(encoder, traces)
+              trace_hashes = traces.map do |trace|
+                encode_trace(trace)
+              end
+
+              # Wrap traces & encode them
+              encoder.encode(traces: trace_hashes)
+            end
+
+            private
+
+            def encode_trace(trace)
+              # Convert each trace to hash
+              trace.spans.map(&:to_hash).tap do |spans|
+                # Convert IDs to hexadecimal
+                spans.each do |span|
+                  ENCODED_IDS.each do |id|
+                    span[id] = span[id].to_s(16) if span.key?(id)
+                  end
+                end
+              end
+            end
+          end
+
+          # Transfer object for list of traces
+          class Parcel
+            include Datadog::Core::Transport::Parcel
+            include Encoder
+
+            def count
+              data.length
+            end
+
+            def encode_with(encoder)
+              encode_traces(encoder, data)
+            end
+          end
+
+          # Add traces behavior to transport components
+          IO::Client.include(Traces::Client)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../../core/encoding'
+require_relative 'io/client'
+require_relative 'io/traces'
+
+module Datadog
+  module Tracing
+    module Transport
+      # Namespace for IO transport components
+      module IO
+        module_function
+
+        # Builds a new Transport::IO::Client
+        def new(out, encoder)
+          Client.new(out, encoder)
+        end
+
+        # Builds a new Transport::IO::Client with default settings
+        # Pass options to override any settings.
+        def default(options = {})
+          new(
+            options.fetch(:out, $stdout),
+            options.fetch(:encoder, Core::Encoding::JSONEncoder)
+          )
+        end
+      end
+    end
+  end
+end