datadog 2.38.0 → 2.47.0

data/lib/datadog/di/serializer.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
+require "date"
 require_relative "redactor"
+require_relative "guardrails_telemetry"
+require_relative "../core/utils/time"
 
 module Datadog
   module DI
-    # Serializes captured snapshot to primitive types, which are subsequently
+    # Serializes captured snapshots to primitive types, which are subsequently
     # serialized to JSON and sent to the backend.
     #
-    # This class performs actual removal of sensitive values from the
-    # snapshots. It uses Redactor to determine which values are sensitive
-    # and need to be removed.
+    # Sensitive values are removed from the snapshots.
     #
     # Serializer normally ought not to invoke user (application) code,
     # to guarantee predictable performance. However, objects like ActiveRecord
@@ -19,7 +20,7 @@ module Datadog
     # thus they won't be captured at all). To accommodate complex objects,
     # there is an extension mechanism implemented permitting registration
     # of serializer callbacks for arbitrary types. Applications and libraries
-    # definining such serializer callbacks should be very careful to
+    # defining such serializer callbacks should be very careful to
     # have predictable performance and avoid exceptions and infinite loops
     # and other such issues.
     #
@@ -36,20 +37,23 @@ module Datadog
     # efficient but there would be additional overhead from passing this
     # parameter all the time and the API would get more complex.
     #
-    # Note: "self" cannot be used as a parameter name in Ruby, therefore
-    # there should never be a conflict between instance variable
-    # serialization and method parameters.
-    #
     # @api private
     class Serializer
-      # Exception classes that should never be caught during serialization.
-      # These represent fatal conditions (signals, interrupts, system exit)
-      # that must propagate to the caller. NoMemoryError is deliberately
-      # excluded (unlike DI::FATAL_EXCEPTION_CLASSES): serialization of large
-      # or deeply recursive objects can exhaust memory, and the serializer must
-      # return a safe stub rather than tear the process down.
+      # Exception classes that must propagate to the caller during
+      # serialization: fatal conditions (signals, interrupts, system exit).
+      # NoMemoryError is deliberately excluded (unlike
+      # DI::FATAL_EXCEPTION_CLASSES): serialization of large or deeply
+      # recursive objects can exhaust memory, and the serializer must return
+      # a safe stub rather than terminate the process.
       SERIALIZABLE_FATAL_EXCEPTION_CLASSES = [SystemExit, SignalException].freeze
 
+      # Placeholder emitted by #serialize_value_for_message in place of a value
+      # whose identifier or type matches the redaction configuration. The
+      # message-path counterpart of the +notCapturedReason+
+      # "redactedIdent"/"redactedType" markers that #serialize_value produces
+      # on the snapshot path.
+      REDACTED_VALUE_FOR_MESSAGE = "[redacted]"
+
       # Third-party library integration / custom serializers.
       #
       # Dynamic instrumentation has limited payload sizes, and for efficiency
@@ -92,20 +96,63 @@ module Datadog
       # hex string, or UTF-8 with replacement characters) before returning
       # it from the custom serializer.
       @@flat_registry = []
-      def self.register(condition: nil, &block)
+      # Registers a custom serializer. The block serializes each value
+      # for which +condition+ returns a truthy value.
+      #
+      # @param condition [Proc] receives the value being serialized and
+      #   returns whether this serializer applies to it
+      # @param block [Proc] serializer for the values +condition+ accepts
+      # @raise [ArgumentError] if +condition+ is not a Proc or +block+ is absent
+      # @return [void]
+      def self.register(condition:, &block)
+        unless condition.is_a?(Proc)
+          raise ArgumentError, "Serializer.register condition must be a Proc, got #{condition.class}"
+        end
+
+        unless block
+          raise ArgumentError, "Serializer.register requires a serializer block"
+        end
+
         @@flat_registry << {condition: condition, proc: block}
+        nil
       end
 
-      def initialize(settings, redactor, telemetry: nil)
+      # Initializes the serializer.
+      #
+      # @param settings [Datadog::Core::Configuration::Settings] tracer settings
+      # @param redactor [Redactor] redactor gating captured values
+      # @param logger [DI::Logger] logger for contained serialization failures
+      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical capture-incomplete metric
+      # @param telemetry [Datadog::Core::Telemetry::Component, nil] component serializer errors are reported through
+      # @return [void]
+      def initialize(settings, redactor, logger:, guardrails_telemetry:, telemetry: nil)
         @settings = settings
         @redactor = redactor
+        @logger = logger
+        @guardrails_telemetry = guardrails_telemetry
         @telemetry = telemetry
       end
 
       attr_reader :settings
       attr_reader :redactor
+      # The logger.
+      # @return [DI::Logger]
+      attr_reader :logger
+      # The guardrails metric emitter.
+      # @return [GuardrailsTelemetry]
+      attr_reader :guardrails_telemetry
       attr_reader :telemetry
 
+      # Emits the canonical capture-incomplete metric for a capture limit
+      # enforced while serializing a snapshot, with the snapshot event
+      # type.
+      #
+      # @param reason [String] a GuardrailsTelemetry::Reason constant naming the enforced limit
+      # @return [void]
+      def record_capture_incomplete(reason)
+        guardrails_telemetry.capture_incomplete(reason: reason, event_type: GuardrailsTelemetry::EVENT_TYPE_SNAPSHOT)
+      end
+
       def combine_args(args, kwargs, target_self)
         counter = 0
         combined = args.each_with_object({}) do |value, c|
@@ -126,31 +173,39 @@ module Datadog
       # arguments to keyword arguments ("arg1", "arg2", ...) and ensure
       # the positional arguments are listed first.
       #
-      # Instance variables are technically a hash just like kwargs,
-      # we take them as a separate parameter to avoid a hash merge
-      # in upstream code.
+      # @param args [Array] positional arguments passed to the probed method
+      # @param kwargs [Hash{Symbol => Object}] keyword arguments passed to the probed method
+      # @param target_self [any] receiver of the probed method invocation
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
+      # @return [Hash{Symbol => Hash}] serialized arguments keyed by argument name
       def serialize_args(args, kwargs, target_self,
+        deadline:,
         depth: settings.dynamic_instrumentation.max_capture_depth,
         attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count,
         length: nil,
         collection_size: nil)
         combined = combine_args(args, kwargs, target_self)
         serialize_vars(combined, depth: depth, attribute_count: attribute_count,
-          length: length, collection_size: collection_size)
+          length: length, collection_size: collection_size, deadline: deadline,)
       end
 
       # Serializes variables captured by a line probe.
       #
       # These are normally local variables that exist on a particular line
       # of executed code.
+      #
+      # @param vars [Hash{Symbol => Object}] variables to serialize, keyed by variable name
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
+      # @return [Hash{Symbol => Hash}] serialized variables keyed by variable name
       def serialize_vars(vars,
+        deadline:,
         depth: settings.dynamic_instrumentation.max_capture_depth,
         attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count,
         length: nil,
         collection_size: nil)
         vars.each_with_object({}) do |(k, v), agg|
           agg[k] = serialize_value(v, name: k, depth: depth, attribute_count: attribute_count,
-            length: length, collection_size: collection_size)
+            length: length, collection_size: collection_size, deadline: deadline,)
         end
       end
 
@@ -166,7 +221,13 @@ module Datadog
       # (integers, strings, arrays, hashes).
       #
       # Respects string length, collection size and traversal depth limits.
-      def serialize_value(value, name: nil,
+      #
+      # @param value [any] value to serialize
+      # @param name [Symbol, String, nil] name the value is bound to, used for redaction
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
+      # @return [Hash{Symbol => Object}] serialized value; the {type:, notCapturedReason: "timeout"} stub when the deadline is exceeded
+      def serialize_value(value, deadline:,
+        name: nil,
         depth: settings.dynamic_instrumentation.max_capture_depth,
         attribute_count: nil,
         length: nil,
@@ -175,6 +236,12 @@ module Datadog
         attribute_count ||= settings.dynamic_instrumentation.max_capture_attribute_count
         cls = type || value.class
         begin
+          if deadline_exceeded?(deadline)
+            telemetry&.inc(DI::TELEMETRY_NAMESPACE, "serialized_values_skipped_by_timeout", 1)
+            record_capture_incomplete(GuardrailsTelemetry::Reason::CAPTURE_TIMEOUT)
+            return {type: class_name(cls), notCapturedReason: "timeout"}
+          end
+
           if redactor.redact_type?(value)
             return {type: class_name(cls), notCapturedReason: "redactedType"}
           end
@@ -206,7 +273,7 @@ module Datadog
 
               if condition_result
                 serializer_proc = entry.fetch(:proc)
-                return serializer_proc.call(self, value, name: nil, depth: depth)
+                return serializer_proc.call(self, value, name: nil, depth: depth, deadline: deadline)
               end
             end
           end
@@ -220,8 +287,6 @@ module Datadog
           when Integer, Float, TrueClass, FalseClass
             serialized.update(value: value.to_s)
           when Time
-            # This path also handles DateTime values although they do not need
-            # to be explicitly added to the case statement.
             serialized.update(value: value.iso8601)
           when Date
             serialized.update(value: value.to_s)
@@ -239,27 +304,24 @@ module Datadog
             end
 
             # Handle binary strings and invalid UTF-8 by escaping to JSON-safe format.
-            # See escape_binary_string for details on the escaping format.
-            #
-            # Truncate binary data BEFORE escaping to avoid cutting mid-escape-sequence.
             # For regular strings, the limit is applied to string length in characters.
             length ||= settings.dynamic_instrumentation.max_capture_string_length
             max = length
 
             if value.encoding == Encoding::BINARY || !value.valid_encoding?
-              # Truncate binary data BEFORE escaping to avoid cutting mid-escape-sequence
+              # Truncate binary data before escaping to avoid cutting mid-escape-sequence
               # For invalid encodings, use bytesize instead of length to avoid encoding errors
               original_size = value.bytesize
               if original_size > max
                 serialized.update(truncated: true, size: original_size)
+                record_capture_incomplete(GuardrailsTelemetry::Reason::STRING_LENGTH)
                 value = value.byteslice(0...max)
               end
               value = escape_binary_string(value) # steep:ignore ArgumentTypeMismatch
-              false # Already converted to a new string
             else
-              # Truncate non-binary strings
               if value.length > max
                 serialized.update(truncated: true, size: value.length)
+                record_capture_incomplete(GuardrailsTelemetry::Reason::STRING_LENGTH)
                 value = value[0...max]
                 need_dup = false
               end
@@ -271,23 +333,32 @@ module Datadog
           when Array
             if depth <= 0
               serialized.update(notCapturedReason: "depth")
+              record_capture_incomplete(GuardrailsTelemetry::Reason::DEPTH)
             else
               collection_size ||= settings.dynamic_instrumentation.max_capture_collection_size
               max = collection_size
               if max != 0 && value.length > max
                 serialized.update(notCapturedReason: "collectionSize", size: value.length)
+                record_capture_incomplete(GuardrailsTelemetry::Reason::COLLECTION_SIZE)
                 # same steep failure with array slices.
                 # https://github.com/soutaro/steep/issues/1219
                 value = value[0...max] || []
               end
-              entries = value.map do |elt|
-                serialize_value(elt, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count)
+              entries = []
+              value.each do |elt|
+                entry = serialize_value(elt, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count, deadline: deadline)
+                entries << entry
+                if entry[:notCapturedReason] == "timeout"
+                  serialized.update(notCapturedReason: "timeout")
+                  break
+                end
               end
               serialized.update(elements: entries)
             end
           when Hash
             if depth <= 0
               serialized.update(notCapturedReason: "depth")
+              record_capture_incomplete(GuardrailsTelemetry::Reason::DEPTH)
             else
               collection_size ||= settings.dynamic_instrumentation.max_capture_collection_size
               max = collection_size
@@ -296,17 +367,28 @@ module Datadog
               value.each do |k, v|
                 if max != 0 && cur >= max
                   serialized.update(notCapturedReason: "collectionSize", size: value.length)
+                  record_capture_incomplete(GuardrailsTelemetry::Reason::COLLECTION_SIZE)
                   break
                 end
                 cur += 1
-                entries << [serialize_value(k, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count),
-                  serialize_value(v, name: k, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count)]
+                key_entry = serialize_value(k, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count, deadline: deadline)
+                if key_entry[:notCapturedReason] == "timeout"
+                  serialized.update(notCapturedReason: "timeout")
+                  break
+                end
+                value_entry = serialize_value(v, name: k, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count, deadline: deadline)
+                entries << [key_entry, value_entry]
+                if value_entry[:notCapturedReason] == "timeout"
+                  serialized.update(notCapturedReason: "timeout")
+                  break
+                end
               end
               serialized.update(entries: entries)
             end
           else
             if depth <= 0
               serialized.update(notCapturedReason: "depth")
+              record_capture_incomplete(GuardrailsTelemetry::Reason::DEPTH)
             else
               fields = {}
               cur = 0
@@ -327,40 +409,42 @@ module Datadog
               #
               # For consistency, we should have some kind of stable order of
               # instance variables on all supported Ruby runtimes, so that the UI
-              # stays consistent. Given that initial implementation of Ruby DI
-              # does not support JRuby, we don't handle JRuby's lack of ordering
-              # of #instance_variables here, but if JRuby is supported in the
-              # future this may need to be addressed.
+              # stays consistent. Ruby DI does not support JRuby, so JRuby's lack
+              # of ordering of #instance_variables is not handled here.
               ivars = value.instance_variables
 
               ivars.each do |ivar|
                 if cur >= attribute_count
                   serialized.update(notCapturedReason: "fieldCount", fields: fields)
+                  record_capture_incomplete(GuardrailsTelemetry::Reason::FIELD_COUNT)
                   break
                 end
                 cur += 1
-                fields[ivar] = serialize_value(value.instance_variable_get(ivar), name: ivar, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count)
+                entry = serialize_value(value.instance_variable_get(ivar), name: ivar, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count, deadline: deadline)
+                fields[ivar] = entry
+                if entry[:notCapturedReason] == "timeout"
+                  serialized.update(notCapturedReason: "timeout")
+                  break
+                end
               end
               serialized.update(fields: fields)
             end
           end
           serialized
         rescue Exception => exc # standard:disable Lint/RescueException
-          # Re-raise fatal exceptions that should not be caught
-          # (signals, interrupts, system exit)
           raise if SERIALIZABLE_FATAL_EXCEPTION_CLASSES.any? { |klass| exc.is_a?(klass) }
 
-          # Catch all other exceptions including SystemStackError and NoMemoryError.
-          # These inherit from Exception (not StandardError) but can occur during
-          # serialization (e.g., infinite recursion in custom serializers, memory
-          # exhaustion from large objects) and should return a safe structure
-          # rather than propagating to the transport layer.
+          # Catch all remaining exceptions: SystemStackError and NoMemoryError can
+          # occur during serialization (e.g. a custom serializer recursing
+          # infinitely) and produce the safe stub.
+          record_capture_incomplete(GuardrailsTelemetry::Reason::RUNTIME_ERROR)
+          logger.debug { "di: error serializing value of #{class_name(cls)}: #{exc.class}: #{exc.message}" }
           telemetry&.report(exc, description: "Error serializing")
           {type: class_name(cls), notSerializedReason: exc.to_s}
         end
       end
 
-      # This method is used for serializing arbitrary values into log messages.
+      # Serializes a value for interpolation into a log-probe message.
       # Because the output is meant to be human-readable, we cannot use
       # the "normal" serialization format which is meant to be machine-readable.
       # Serialize objects with depth of 1 and include the class name.
@@ -375,33 +459,43 @@ module Datadog
       #
       # We also use the Ruby-like syntax for symbols, which don't exist
       # in other languages.
-      def serialize_value_for_message(value, depth = 1)
+      #
+      # +name+, when given, is the identifier the template expression
+      # references at its top level; a redacted identifier yields the
+      # redaction placeholder, mirroring #serialize_value on the snapshot path.
+      # Message rendering is capped by depth (1) and
+      # MAX_MESSAGE_COLLECTION_SIZE / MAX_MESSAGE_ATTRIBUTE_COUNT.
+      def serialize_value_for_message(value, depth: 1, name: nil)
         # This method is more verbose than "normal" Ruby code to avoid
         # array allocations.
+
+        return REDACTED_VALUE_FOR_MESSAGE if redactor.redact_type?(value)
+        return REDACTED_VALUE_FOR_MESSAGE if name && redactor.redact_identifier?(name)
+
         case value
         when NilClass
-          'nil'
+          "nil"
         when Integer, Float, TrueClass, FalseClass, Time, Date
           value.to_s
         when String
           serialize_string_or_symbol_for_message(value)
         when Symbol
-          ':' + serialize_string_or_symbol_for_message(value) # steep:ignore ArgumentTypeMismatch
+          ":" + serialize_string_or_symbol_for_message(value) # steep:ignore ArgumentTypeMismatch
         when Array
-          return '...' if depth <= 0
+          return "..." if depth <= 0
 
           max = max_capture_collection_size_for_message
           if value.length > max
             value_ = value[0...max - 1] || []
-            value_ << '...'
+            value_ << "..."
             value_ << value[-1]
             value = value_
           end
-          '[' + value.map do |item|
-            serialize_value_for_message(item, depth - 1)
-          end.join(', ') + ']'
+          "[" + value.map do |item|
+            serialize_value_for_message(item, depth: depth - 1)
+          end.join(", ") + "]"
         when Hash
-          return '...' if depth <= 0
+          return "..." if depth <= 0
 
           max = max_capture_collection_size_for_message
           keys = value.keys
@@ -413,15 +507,20 @@ module Datadog
             truncated = true
           end
           serialized = keys.map do |key|
-            "#{serialize_value_for_message(key, depth - 1)} => #{serialize_value_for_message(value[key], depth - 1)}"
+            serialized_value = if (String === key || Symbol === key) && redactor.redact_identifier?(key)
+              REDACTED_VALUE_FOR_MESSAGE
+            else
+              serialize_value_for_message(value[key], depth: depth - 1)
+            end
+            "#{serialize_value_for_message(key, depth: depth - 1)} => #{serialized_value}"
           end
           if truncated
             serialized[serialized.length] = serialized[serialized.length - 1]
-            serialized[serialized.length - 2] = '...'
+            serialized[serialized.length - 2] = "..."
           end
           "{#{serialized.join(", ")}}"
         else
-          return '...' if depth <= 0
+          return "..." if depth <= 0
 
           vars = value.instance_variables
           truncated = false
@@ -435,14 +534,19 @@ module Datadog
           serialized = vars.map do |var|
             # +var+ here is always the instance variable name which is a
             # symbol, we do not need to run it through our serializer.
-            "#{var}=#{serialize_value_for_message(value.send(:instance_variable_get, var), depth - 1)}"
+            serialized_value = if redactor.redact_identifier?(var)
+              REDACTED_VALUE_FOR_MESSAGE
+            else
+              serialize_value_for_message(value.send(:instance_variable_get, var), depth: depth - 1)
+            end
+            "#{var}=#{serialized_value}"
           end
           if truncated
             serialized << serialized.last
-            serialized[-2] = '...'
+            serialized[-2] = "..."
           end
           serialized = if serialized.any?
-            ' ' + serialized.join(' ')
+            " " + serialized.join(" ")
           end
           "#<#{class_name(value.class)}#{serialized}>"
         end
@@ -450,13 +554,26 @@ module Datadog
         raise if SERIALIZABLE_FATAL_EXCEPTION_CLASSES.any? { |klass| exc.is_a?(klass) }
 
         telemetry&.report(exc, description: "Error serializing for message")
-        # TODO class_name(foo) can also fail, which we don't handle here.
-        # Telemetry reporting could potentially also fail?
+        # TODO handle class_name raising here as well.
         "#<#{class_name(value.class)}: serialization error>"
       end
 
+      # Computes the absolute thread CPU time deadline (in seconds) for a
+      # capture point from max_time_to_serialize_ms.
+      #
+      # @return [Float] absolute thread CPU clock reading, in seconds, at
+      #   which the capture budget is exhausted
+      def serialization_deadline
+        Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) +
+          settings.dynamic_instrumentation.max_time_to_serialize_ms / 1000.0
+      end
+
       private
 
+      def deadline_exceeded?(deadline)
+        Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) >= deadline
+      end
+
       MAX_MESSAGE_COLLECTION_SIZE = 3
       MAX_MESSAGE_ATTRIBUTE_COUNT = 5
 
@@ -501,7 +618,7 @@ module Datadog
             if max % 2 == 0
               upper += 1
             end
-            value[0...max / 2 - 1] + '...' + value[upper...length] # steep:ignore NoMethod
+            value[0...max / 2 - 1] + "..." + value[upper...length] # steep:ignore NoMethod
           end
         else
           value
@@ -543,7 +660,7 @@ module Datadog
           when 0x27 # '
             "\\'"
           when 0x5C # \
-            '\\\\'
+            "\\\\"
           when 0x20..0x7E # Printable ASCII (space through ~)
             byte.chr
           else

data/lib/datadog/di/snapshot_event.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    # A snapshot payload queued for sending to the agent, paired with
+    # the guardrails event type of the probe that produced it, so drop
+    # metrics can be tagged with the probe's classification.
+    # @api private
+    class SnapshotEvent
+      # Initializes the event.
+      #
+      # @param payload [Hash] the snapshot payload to send to the agent
+      # @param event_type [String] one of GuardrailsTelemetry::EVENT_TYPE_SNAPSHOT and EVENT_TYPE_LOG
+      # @return [void]
+      def initialize(payload:, event_type:)
+        @payload = payload
+        @event_type = event_type
+      end
+
+      # The snapshot payload to send to the agent.
+      # @return [Hash]
+      attr_reader :payload
+
+      # The guardrails event type of the probe that produced the payload.
+      # @return [String] one of GuardrailsTelemetry::EVENT_TYPE_SNAPSHOT and EVENT_TYPE_LOG
+      attr_reader :event_type
+
+      # Compares two events by payload and event type.
+      #
+      # @param other [Object] the object to compare with
+      # @return [Boolean] whether the other object is an event with the
+      #   same payload and event type
+      def ==(other)
+        other.is_a?(SnapshotEvent) && other.payload == payload && other.event_type == event_type
+      end
+    end
+  end
+end

data/lib/datadog/di/transport/diagnostics.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
-require_relative '../../core/transport/parcel'
-require_relative '../../core/transport/request'
-require_relative '../../core/transport/transport'
-require_relative 'http/diagnostics'
+require_relative "../../core/transport/parcel"
+require_relative "../../core/transport/request"
+require_relative "../../core/transport/transport"
+require_relative "http/diagnostics"
 
 module Datadog
   module DI

data/lib/datadog/di/transport/http/diagnostics.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/http/api/endpoint'
+require_relative "../../../core/transport/http/api/endpoint"
 
 module Datadog
   module DI
@@ -20,9 +20,9 @@ module Datadog
                 event_payload = Core::Vendor::Multipart::Post::UploadIO.new(
                   StringIO.new(env.request.parcel.data),
                   env.request.parcel.content_type,
-                  'event.json',
+                  "event.json",
                 )
-                env.form = {'event' => event_payload}
+                env.form = {"event" => event_payload}
 
                 super
               end

data/lib/datadog/di/transport/http/input.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/http/api/endpoint'
+require_relative "../../../core/transport/http/api/endpoint"
 
 module Datadog
   module DI
@@ -9,7 +9,7 @@ module Datadog
         module Input
           module API
             class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
-              HEADER_CONTENT_TYPE = 'Content-Type'
+              HEADER_CONTENT_TYPE = "Content-Type"
 
               attr_reader \
                 :encoder