datadog 2.38.0 → 2.47.0

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../../core/encoding'
-require_relative '../../core/transport/http'
-require_relative 'diagnostics'
-require_relative 'input'
+require_relative "../../core/encoding"
+require_relative "../../core/transport/http"
+require_relative "diagnostics"
+require_relative "input"
 
 module Datadog
   module DI
@@ -11,12 +11,12 @@ module Datadog
       # Namespace for HTTP transport components
       module HTTP
         DIAGNOSTICS = Diagnostics::API::Endpoint.new(
-          '/debugger/v1/diagnostics',
+          "/debugger/v1/diagnostics",
           Core::Encoding::JSONEncoder,
         )
 
         INPUT = Input::API::Endpoint.new(
-          '/debugger/v2/input',
+          "/debugger/v2/input",
           Core::Encoding::JSONEncoder,
         )
 
@@ -24,7 +24,7 @@ module Datadog
           # We used to use /debugger/v1/input, but now input
           # payloads should be going to the diagnostics endpoint
           # which I gather performs data redaction.
-          '/debugger/v1/diagnostics',
+          "/debugger/v1/diagnostics",
           Core::Encoding::JSONEncoder,
         )
 
@@ -40,18 +40,27 @@ module Datadog
             agent_settings: agent_settings,
             headers: headers,
           ) do |transport|
-            transport.api 'diagnostics', DIAGNOSTICS
+            transport.api "diagnostics", DIAGNOSTICS
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?
           end.to_transport(DI::Transport::Diagnostics::Transport)
         end
 
-        # Builds a new Transport::HTTP::Client with default settings
-        # Pass a block to override any settings.
+        # Builds the snapshot input transport. Pass a block to override
+        # any transport settings.
+        #
+        # @param agent_settings [Datadog::Core::Configuration::AgentSettings] agent connection settings
+        # @param logger [DI::Logger] logger for transport diagnostics
+        # @param headers [Hash{String => String}, nil] headers to send with every request
+        # @param telemetry [Datadog::Core::Telemetry::Component, nil] component transport errors are reported through
+        # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical guardrails drop metric
+        # @return [DI::Transport::Input::Transport]
+        # @yield [builder] block overriding the default transport builder settings
         def self.input(
           agent_settings:,
           logger:,
+          guardrails_telemetry:,
           headers: nil,
           telemetry: nil
         )
@@ -60,8 +69,8 @@ module Datadog
             agent_settings: agent_settings,
             headers: headers,
           ) do |transport|
-            transport.api 'input', INPUT, fallback: 'legacy_input', default: true
-            transport.api 'legacy_input', LEGACY_INPUT
+            transport.api "input", INPUT, fallback: "legacy_input", default: true
+            transport.api "legacy_input", LEGACY_INPUT
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?
@@ -72,7 +81,8 @@ module Datadog
             builder.to_api_instances,
             builder.default_api,
             logger: logger,
-            telemetry: telemetry
+            telemetry: telemetry,
+            guardrails_telemetry: guardrails_telemetry,
           )
         end
       end

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

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
-require_relative '../../core/chunker'
-require_relative '../../core/encoding'
-require_relative '../../core/tag_builder'
-require_relative '../../core/transport/parcel'
-require_relative '../../core/transport/request'
-require_relative '../../core/transport/transport'
-require_relative '../error'
-require_relative '../fatal_exceptions'
-require_relative 'http/input'
+require_relative "../../core/chunker"
+require_relative "../../core/encoding"
+require_relative "../../core/tag_builder"
+require_relative "../../core/transport/parcel"
+require_relative "../../core/transport/request"
+require_relative "../../core/transport/transport"
+require_relative "../error"
+require_relative "../fatal_exceptions"
+require_relative "../guardrails_telemetry"
+require_relative "http/input"
 
 module Datadog
   module DI
@@ -26,10 +27,22 @@ module Datadog
 
         class Transport < Core::Transport::Transport
           attr_reader :telemetry
+          # The guardrails metric emitter.
+          # @return [GuardrailsTelemetry]
+          attr_reader :guardrails_telemetry
 
-          def initialize(apis, default_api, logger:, telemetry: nil)
+          # Initializes the transport.
+          #
+          # @param apis [Datadog::Core::Transport::HTTP::API::Map] API instances by name
+          # @param default_api [String] name of the API requests are sent through when unspecified
+          # @param logger [Datadog::Core::Logger] logger for transport diagnostics
+          # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical payload-drop metric
+          # @param telemetry [Datadog::Core::Telemetry::Component, nil] component transport errors are reported through
+          # @return [void]
+          def initialize(apis, default_api, logger:, guardrails_telemetry:, telemetry: nil)
             super(apis, default_api, logger: logger)
             @telemetry = telemetry
+            @guardrails_telemetry = guardrails_telemetry
           end
 
           # The limit on an individual snapshot payload, aka "log line",
@@ -62,19 +75,24 @@ module Datadog
           # Large snapshots (> 1MB) are dropped. Batches are split into chunks
           # of ~2MB each to avoid large network requests.
           #
-          # @param payload [Array<Hash>] Array of snapshot payloads
+          # @param payload [Array<SnapshotEvent>] the snapshot events to send, each paired with its probe's guardrails event type
           # @param tags [Hash] Tags to send with the snapshots
           # @param on_serialization_error [Proc] Called with (probe_id, exception)
           #   when a snapshot fails to serialize.
+          # @return [Array<SnapshotEvent>] the events that were sent
           def send_input(payload, tags, on_serialization_error:)
             serialized_tags = Core::TagBuilder.serialize_tags(tags)
 
             # Serialize each snapshot individually to isolate failures
             encoded_snapshots = []
-            payload.each do |snapshot|
-              encoded = encoder.encode(snapshot)
-              if encoded.length > MAX_SERIALIZED_SNAPSHOT_SIZE
-                logger.debug { "di: dropping too big snapshot" }
+            dropped_events = []
+            payload.each do |event|
+              encoded = encoder.encode(event.payload)
+              if encoded.bytesize > MAX_SERIALIZED_SNAPSHOT_SIZE
+                logger.debug do
+                  "di: dropping too big snapshot (#{GuardrailsTelemetry::Reason::PAYLOAD_TOO_LARGE})"
+                end
+                dropped_events << [event, encoded.bytesize]
                 next
               end
               encoded_snapshots << encoded
@@ -82,7 +100,7 @@ module Datadog
               Datadog::DI.reraise_if_fatal(exc)
               # Serialization failed for this snapshot - report via callback
               # This catches JSON::GeneratorError, Encoding errors, TypeError, etc.
-              probe_id = snapshot.dig(:debugger, :snapshot, :probe, :id)
+              probe_id = event.payload.dig(:debugger, :snapshot, :probe, :id)
               logger.debug { "di: JSON encoding failed for snapshot (probe #{probe_id}): #{exc.class}: #{exc.message}" }
               telemetry&.report(exc, description: "JSON encoding failed for snapshot")
 
@@ -97,6 +115,13 @@ module Datadog
               end
             end
 
+            dropped_events.each do |event, bytes|
+              guardrails_telemetry.dropped(
+                reason: GuardrailsTelemetry::Reason::PAYLOAD_TOO_LARGE,
+                event_type: event.event_type, bytes: bytes,
+              )
+            end
+
             return payload if encoded_snapshots.empty?
 
             Datadog::Core::Chunker.chunk_by_size(

data/lib/datadog/di/utils.rb

@@ -86,7 +86,7 @@ module Datadog
       # forward slashes (DEBUG-5111). Used to normalize probe source paths
       # that originate from IDE tooling running on Windows.
       module_function def normalize_windows_separators(path)
-        path.tr('\\', '/')
+        path.tr("\\", "/")
       end
 
       # Returns whether the provided +path+ matches the user-designated
@@ -120,7 +120,7 @@ module Datadog
           suffix = suffix.downcase
         end
 
-        if suffix.start_with?('/')
+        if suffix.start_with?("/")
           path == suffix
         else
           # Exact match is not possible here, meaning any matching path
@@ -156,8 +156,8 @@ module Datadog
           return true if path_matches_suffix?(path, working_spec, case_insensitive: case_insensitive)
 
           loop do
-            break unless working_spec.include?('/')
-            working_spec.sub!(%r{.*/+}, '')
+            break unless working_spec.include?("/")
+            working_spec.sub!(%r{.*/+}, "")
             return true if path_matches_suffix?(path, working_spec, case_insensitive: case_insensitive)
           end
         end

data/lib/datadog/di.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'di/configuration'
-require_relative 'di/extensions'
-require_relative 'di/remote'
+require_relative "di/configuration"
+require_relative "di/extensions"
+require_relative "di/remote"
 
 module Datadog
   # Namespace for Datadog dynamic instrumentation.
@@ -127,9 +127,9 @@ module Datadog
       #
       # @return [String, nil]
       private def unsupported_platform_reason
-        if RUBY_ENGINE != 'ruby'
+        if RUBY_ENGINE != "ruby"
           "MRI is required, but running on #{RUBY_ENGINE}"
-        elsif Datadog::RubyVersion.is?('< 2.6')
+        elsif Datadog::RubyVersion.is?("< 2.6")
           "Ruby 2.6+ is required, but running on #{RUBY_VERSION}"
         end
       end

data/lib/datadog/error_tracking/collector.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require_relative '../ruby_version'
+require_relative "ext"
+require_relative "../ruby_version"
 
 module Datadog
   module ErrorTracking

data/lib/datadog/error_tracking/component.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative 'collector'
-require_relative 'filters'
+require "set"
+require_relative "collector"
+require_relative "filters"
 
 module Datadog
   module ErrorTracking
@@ -30,10 +30,10 @@ module Datadog
         end
 
         def environment_supported?(logger)
-          if RUBY_ENGINE != 'ruby'
+          if RUBY_ENGINE != "ruby"
             logger.warn("error tracking: cannot enable error tracking: MRI is required, but running on #{RUBY_ENGINE}")
             false
-          elsif RubyVersion.is?('< 2.7')
+          elsif RubyVersion.is?("< 2.7")
             logger.warn(
               "error tracking: cannot enable error tracking: Ruby 2.7+ is required, but running
               on #{RUBY_VERSION}"
@@ -63,7 +63,7 @@ module Datadog
         # Before Ruby3.3 the TracePoint listen for :raise events.
         # If an error is not handled, we will delete the according
         # span event in the collector.
-        event = RubyVersion.is?('>= 3.3') ? :rescue : :raise
+        event = RubyVersion.is?(">= 3.3") ? :rescue : :raise
 
         # This TracePoint is in charge of capturing the handled exceptions
         # and of adding the corresponding span events to the collector
@@ -113,9 +113,9 @@ module Datadog
             # - otherwise we just check if the name provided is in the path and is
             #   either the name of a folder or of a ruby file.
             regex =
-              if file_to_instr.start_with?('/')
+              if file_to_instr.start_with?("/")
                 %r{\A#{Regexp.escape(file_to_instr)}(?:/|\.rb\z|\z)}
-              elsif file_to_instr.start_with?('./')
+              elsif file_to_instr.start_with?("./")
                 abs_path = File.expand_path(file_to_instr)
                 %r{\A#{Regexp.escape(abs_path)}(?:/|\.rb\z|\z)}
               else
@@ -152,11 +152,11 @@ module Datadog
       def generate_span_event(exception)
         formatted_exception = Datadog::Core::Error.build_from(exception)
         attributes = {
-          'exception.type' => formatted_exception.type,
-          'exception.message' => formatted_exception.message,
-          'exception.stacktrace' => formatted_exception.backtrace
+          "exception.type" => formatted_exception.type,
+          "exception.message" => formatted_exception.message,
+          "exception.stacktrace" => formatted_exception.backtrace,
         }
-        Datadog::Tracing::SpanEvent.new('exception', attributes: attributes)
+        Datadog::Tracing::SpanEvent.new("exception", attributes: attributes)
       end
 
       def add_instrumented_file(file_path)

data/lib/datadog/error_tracking/configuration.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
+require_relative "ext"
 
 module Datadog
   module ErrorTracking
@@ -35,7 +35,7 @@ module Datadog
                     Datadog.logger.warn(
                       "Invalid handled errors scope: #{value}. " \
                       "Supported values are: #{Ext::VALID_HANDLED_ERRORS.join(" | ")}. " \
-                      'Deactivating the feature.'
+                      "Deactivating the feature."
                     )
                   end
 

data/lib/datadog/error_tracking/ext.rb

@@ -4,15 +4,15 @@ module Datadog
   module ErrorTracking
     # Error Tracking constants
     module Ext
-      ENV_HANDLED_ERRORS = 'DD_ERROR_TRACKING_HANDLED_ERRORS'
-      ENV_HANDLED_ERRORS_INCLUDE = 'DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE'
-      HANDLED_ERRORS_ALL = 'all'
-      HANDLED_ERRORS_USER = 'user'
-      HANDLED_ERRORS_THIRD_PARTY = 'third_party'
+      ENV_HANDLED_ERRORS = "DD_ERROR_TRACKING_HANDLED_ERRORS"
+      ENV_HANDLED_ERRORS_INCLUDE = "DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE"
+      HANDLED_ERRORS_ALL = "all"
+      HANDLED_ERRORS_USER = "user"
+      HANDLED_ERRORS_THIRD_PARTY = "third_party"
       DEFAULT_HANDLED_ERRORS = nil
       VALID_HANDLED_ERRORS = [HANDLED_ERRORS_ALL, HANDLED_ERRORS_USER, HANDLED_ERRORS_THIRD_PARTY].freeze
-      SPAN_EVENTS_HAS_EXCEPTION = '_dd.span_events.has_exception'
-      RUBY_VERSION_WITH_RESCUE_EVENT = '3.3'
+      SPAN_EVENTS_HAS_EXCEPTION = "_dd.span_events.has_exception"
+      RUBY_VERSION_WITH_RESCUE_EVENT = "3.3"
     end
   end
 end

data/lib/datadog/error_tracking/extensions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'configuration'
-require_relative '../core/configuration'
+require_relative "configuration"
+require_relative "../core/configuration"
 
 module Datadog
   module ErrorTracking

data/lib/datadog/error_tracking/filters.rb

@@ -32,7 +32,7 @@ module Datadog
       end
 
       def datadog_code?(file_path)
-        file_path.include?('lib/datadog/')
+        file_path.include?("lib/datadog/")
       end
 
       def third_party_code?(file_path)
@@ -48,9 +48,9 @@ module Datadog
       def generate_filter(to_instrument_scope, handled_errors_include = nil)
         case to_instrument_scope
         # If DD_ERROR_TRACKING_HANDLED_ERRORS is set
-        when 'all'
+        when "all"
           proc { |file_path| !datadog_code?(file_path) }
-        when 'user'
+        when "user"
           # If DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE is set
           if handled_errors_include
             proc { |file_path|
@@ -59,7 +59,7 @@ module Datadog
           else
             proc { |file_path| user_code?(file_path) }
           end
-        when 'third_party'
+        when "third_party"
           if handled_errors_include
             proc { |file_path|
               third_party_code?(file_path) || file_included?(file_path, handled_errors_include)

data/lib/datadog/error_tracking.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'error_tracking/collector'
-require_relative 'error_tracking/component'
-require_relative 'error_tracking/configuration'
-require_relative 'error_tracking/ext'
-require_relative 'error_tracking/extensions'
-require_relative 'error_tracking/filters'
+require_relative "error_tracking/collector"
+require_relative "error_tracking/component"
+require_relative "error_tracking/configuration"
+require_relative "error_tracking/ext"
+require_relative "error_tracking/extensions"
+require_relative "error_tracking/filters"
 
 module Datadog
   # Namespace for Datadog ErrorTracking.

data/lib/datadog/kit/appsec/events/v2.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../identity'
-require_relative '../../../appsec/trace_keeper'
+require_relative "../../identity"
+require_relative "../../../appsec/trace_keeper"
 
 module Datadog
   module Kit
@@ -9,17 +9,17 @@ module Datadog
       module Events
         # The second version of Business Logic Events SDK
         module V2
-          SIGNUP_EVENT = 'users.signup'
-          LOGIN_SUCCESS_EVENT = 'users.login.success'
-          LOGIN_FAILURE_EVENT = 'users.login.failure'
+          SIGNUP_EVENT = "users.signup"
+          LOGIN_SUCCESS_EVENT = "users.login.success"
+          LOGIN_FAILURE_EVENT = "users.login.failure"
 
-          TELEMETRY_METRICS_NAMESPACE = 'appsec'
-          TELEMETRY_METRICS_SDK_EVENT = 'sdk.event'
-          TELEMETRY_METRICS_SDK_VERSION = 'v2'
+          TELEMETRY_METRICS_NAMESPACE = "appsec"
+          TELEMETRY_METRICS_SDK_EVENT = "sdk.event"
+          TELEMETRY_METRICS_SDK_VERSION = "v2"
           TELEMETRY_METRICS_EVENTS_INTO_TYPES = {
-            LOGIN_SUCCESS_EVENT => 'login_success',
-            LOGIN_FAILURE_EVENT => 'login_failure',
-            SIGNUP_EVENT => 'signup'
+            LOGIN_SUCCESS_EVENT => "login_success",
+            LOGIN_FAILURE_EVENT => "login_failure",
+            SIGNUP_EVENT => "signup",
           }.freeze
 
           class << self
@@ -50,31 +50,31 @@ module Datadog
 
               if trace.nil? || span.nil?
                 return Datadog.logger.warn(
-                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events"
                 )
               end
 
-              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
-              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+              raise TypeError, "`login` argument must be a String" unless login.is_a?(String)
+              raise TypeError, "`metadata` argument must be a Hash" unless metadata.is_a?(Hash)
 
               user_attributes = build_user_attributes(user_or_id, login)
 
               set_span_tags(span, metadata, namespace: LOGIN_SUCCESS_EVENT)
               set_span_tags(span, user_attributes, namespace: "#{LOGIN_SUCCESS_EVENT}.usr")
-              span.set_tag('appsec.events.users.login.success.track', 'true')
-              span.set_tag('_dd.appsec.events.users.login.success.sdk', 'true')
+              span.set_tag("appsec.events.users.login.success.track", "true")
+              span.set_tag("_dd.appsec.events.users.login.success.sdk", "true")
 
               ::Datadog::AppSec::TraceKeeper.keep!(trace)
 
               record_event_telemetry_metric(LOGIN_SUCCESS_EVENT)
-              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_SUCCESS_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push("appsec.events.user_lifecycle", LOGIN_SUCCESS_EVENT)
 
               return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id)
 
               # NOTE: This is a fallback for the case when we don't have an ID,
               #       but need to trigger WAF.
               user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
-              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+              ::Datadog::AppSec::Instrumentation.gateway.push("identity.set_user", user)
             end
 
             # Attach user login failure information to the service entry span
@@ -102,30 +102,30 @@ module Datadog
 
               if trace.nil? || span.nil?
                 return Datadog.logger.warn(
-                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events"
                 )
               end
 
-              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
-              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+              raise TypeError, "`login` argument must be a String" unless login.is_a?(String)
+              raise TypeError, "`metadata` argument must be a Hash" unless metadata.is_a?(Hash)
 
               unless user_exists.is_a?(TrueClass) || user_exists.is_a?(FalseClass)
-                raise TypeError, '`user_exists` argument must be a boolean'
+                raise TypeError, "`user_exists` argument must be a boolean"
               end
 
               set_span_tags(span, metadata, namespace: LOGIN_FAILURE_EVENT)
-              span.set_tag('appsec.events.users.login.failure.track', 'true')
-              span.set_tag('_dd.appsec.events.users.login.failure.sdk', 'true')
-              span.set_tag('appsec.events.users.login.failure.usr.login', login)
-              span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists.to_s)
+              span.set_tag("appsec.events.users.login.failure.track", "true")
+              span.set_tag("_dd.appsec.events.users.login.failure.sdk", "true")
+              span.set_tag("appsec.events.users.login.failure.usr.login", login)
+              span.set_tag("appsec.events.users.login.failure.usr.exists", user_exists.to_s)
 
               ::Datadog::AppSec::TraceKeeper.keep!(trace)
 
               record_event_telemetry_metric(LOGIN_FAILURE_EVENT)
-              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_FAILURE_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push("appsec.events.user_lifecycle", LOGIN_FAILURE_EVENT)
 
               user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
-              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+              ::Datadog::AppSec::Instrumentation.gateway.push("identity.set_user", user)
             end
 
             # Attach user signup information to the service entry span
@@ -155,19 +155,19 @@ module Datadog
 
               if trace.nil? || span.nil?
                 return Datadog.logger.warn(
-                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events"
                 )
               end
 
-              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
-              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+              raise TypeError, "`login` argument must be a String" unless login.is_a?(String)
+              raise TypeError, "`metadata` argument must be a Hash" unless metadata.is_a?(Hash)
 
               user_attributes = build_user_attributes(user_or_id, login)
 
               set_span_tags(span, metadata, namespace: SIGNUP_EVENT)
               set_span_tags(span, user_attributes, namespace: "#{SIGNUP_EVENT}.usr")
-              span.set_tag('appsec.events.users.signup.track', 'true')
-              span.set_tag('_dd.appsec.events.users.signup.sdk', 'true')
+              span.set_tag("appsec.events.users.signup.track", "true")
+              span.set_tag("_dd.appsec.events.users.signup.sdk", "true")
 
               ::Datadog::AppSec::TraceKeeper.keep!(trace)
 
@@ -179,7 +179,7 @@ module Datadog
                 # NOTE: {Datadog::Kit::Identity.set_user} requires an ID,
                 #       but WAF can evaluate login alone
                 user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
-                ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+                ::Datadog::AppSec::Instrumentation.gateway.push("identity.set_user", user)
               end
             end
 
@@ -202,7 +202,7 @@ module Datadog
             end
 
             def build_user_attributes(user_or_id, login)
-              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+              raise TypeError, "`login` argument must be a String" unless login.is_a?(String)
 
               case user_or_id
               when nil
@@ -210,12 +210,12 @@ module Datadog
               when String
                 {login: login, id: user_or_id}
               when Hash
-                raise ArgumentError, 'missing required user key `:id`' unless user_or_id.key?(:id)
-                raise TypeError, 'user key `:id` must be a String' unless user_or_id[:id].is_a?(String)
+                raise ArgumentError, "missing required user key `:id`" unless user_or_id.key?(:id)
+                raise TypeError, "user key `:id` must be a String" unless user_or_id[:id].is_a?(String)
 
                 user_or_id.merge(login: login)
               else
-                raise TypeError, '`user_or_id` argument must be either String or Hash'
+                raise TypeError, "`user_or_id` argument must be either String or Hash"
               end
             end
 
@@ -235,13 +235,13 @@ module Datadog
 
               if telemetry.nil?
                 return Datadog.logger.debug(
-                  'Kit::AppSec: Telemetry component is unavailable. Skip recording SDK metrics'
+                  "Kit::AppSec: Telemetry component is unavailable. Skip recording SDK metrics"
                 )
               end
 
               tags = {
                 event_type: TELEMETRY_METRICS_EVENTS_INTO_TYPES[event],
-                sdk_version: TELEMETRY_METRICS_SDK_VERSION
+                sdk_version: TELEMETRY_METRICS_SDK_VERSION,
               }
               telemetry.inc(TELEMETRY_METRICS_NAMESPACE, TELEMETRY_METRICS_SDK_EVENT, 1, tags: tags)
             end