datadog 2.0.0.beta1

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative '../identity'
+
+module Datadog
+  module Kit
+    module AppSec
+      # Tracking events
+      module Events
+        LOGIN_SUCCESS_EVENT = 'users.login.success'
+        LOGIN_FAILURE_EVENT = 'users.login.failure'
+        SIGNUP_EVENT = 'users.signup'
+
+        class << self
+          # Attach login success event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user [Hash<Symbol, String>] User information to pass to
+          #   Datadog::Kit::Identity.set_user. Must contain at least :id as key.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_login_success(trace = nil, span = nil, user:, **others)
+            set_trace_and_span_context('track_login_success', trace, span) do |active_trace, active_span|
+              user_options = user.dup
+              user_id = user_options.delete(:id)
+
+              raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+
+              track(LOGIN_SUCCESS_EVENT, active_trace, active_span, **others)
+
+              Kit::Identity.set_user(active_trace, active_span, id: user_id, **user_options)
+            end
+          end
+
+          # Attach login failure event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user_id [String] User id that attempted login
+          # @param user_exists [bool] Whether the user id that did a login attempt exists.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_login_failure(trace = nil, span = nil, user_id:, user_exists:, **others)
+            set_trace_and_span_context('track_login_failure', trace, span) do |active_trace, active_span|
+              raise ArgumentError, 'user_id cannot be nil' if user_id.nil?
+
+              track(LOGIN_FAILURE_EVENT, active_trace, active_span, **others)
+
+              active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id)
+              active_span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists)
+            end
+          end
+
+          # Attach signup event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user [Hash<Symbol, String>] User information to pass to
+          #   Datadog::Kit::Identity.set_user. Must contain at least :id as key.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_signup(trace = nil, span = nil, user:, **others)
+            set_trace_and_span_context('track_signup', trace, span) do |active_trace, active_span|
+              user_options = user.dup
+              user_id = user_options.delete(:id)
+
+              raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+
+              track(SIGNUP_EVENT, active_trace, active_span, **others)
+
+              Kit::Identity.set_user(trace, id: user_id, **user_options)
+            end
+          end
+
+          # Attach custom event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param event [String] Mandatory. Event code.
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param others [Hash<Symbol, String>] Additional free-form
+          #   event information to attach to the trace. Key must not
+          #   be :track.
+          def track(event, trace = nil, span = nil, **others)
+            if trace && span
+              check_trace_span_integrity(trace, span)
+
+              span.set_tag("appsec.events.#{event}.track", 'true')
+              span.set_tag("_dd.appsec.events.#{event}.sdk", 'true')
+
+              others.each do |k, v|
+                raise ArgumentError, 'key cannot be :track' if k.to_sym == :track
+
+                span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
+              end
+
+              trace.keep!
+            else
+              set_trace_and_span_context('track', trace, span) do |active_trace, active_span|
+                active_span.set_tag("appsec.events.#{event}.track", 'true')
+                active_span.set_tag("_dd.appsec.events.#{event}.sdk", 'true')
+
+                others.each do |k, v|
+                  raise ArgumentError, 'key cannot be :track' if k.to_sym == :track
+
+                  active_span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
+                end
+
+                active_trace.keep!
+              end
+            end
+          end
+
+          private
+
+          def set_trace_and_span_context(method, trace = nil, span = nil)
+            if (appsec_scope = Datadog::AppSec.active_scope)
+              trace = appsec_scope.trace
+              span = appsec_scope.service_entry_span
+            end
+
+            trace ||= Datadog::Tracing.active_trace
+            span ||=  trace && trace.active_span || Datadog::Tracing.active_span
+
+            unless trace && span
+              Datadog.logger.debug(
+                "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+                ' to track this events'
+              )
+              return
+            end
+
+            check_trace_span_integrity(trace, span)
+
+            yield(trace, span)
+          end
+
+          def check_trace_span_integrity(trace, span)
+            raise ArgumentError, "span #{span.id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/kit/enable_core_dumps.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Kit
+    # This helper is used to enable core dumps for the current Ruby app. This is useful when debugging native-level
+    # crashes.
+    #
+    # It can be enabled simply by adding `require 'datadog/kit/enable_core_dumps'` to start of the app.
+    module EnableCoreDumps
+      def self.call
+        current_size, maximum_size = Process.getrlimit(:CORE)
+        core_pattern =
+          begin
+            File.read('/proc/sys/kernel/core_pattern').strip
+          rescue
+            '(Could not open /proc/sys/kernel/core_pattern)'
+          end
+
+        enabled_status = "Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'"
+
+        if maximum_size <= 0
+          Kernel.warn("[datadog] Could not enable core dumps on crash, maximum size is #{maximum_size} (disabled).")
+          return
+        elsif maximum_size == current_size
+          Kernel.warn("[datadog] Core dumps already enabled, nothing to do. #{enabled_status}")
+          return
+        end
+
+        begin
+          Process.setrlimit(:CORE, maximum_size)
+        rescue => e
+          Kernel.warn(
+            "[datadog] Failed to enable core dumps. Cause: #{e.class.name} #{e.message} " \
+            "Location: #{Array(e.backtrace).first}"
+          )
+          return
+        end
+
+        if current_size == 0
+          Kernel.warn("[datadog] Enabled core dumps. #{enabled_status}")
+        else
+          Kernel.warn("[datadog] Raised core dump limit. Old size: #{current_size} #{enabled_status}")
+        end
+      end
+    end
+  end
+end
+
+Datadog::Kit::EnableCoreDumps.call

data/lib/datadog/kit/identity.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative '../appsec/instrumentation/gateway/argument'
+
+module Datadog
+  module Kit
+    # Tracking identity via traces
+    module Identity
+      class << self
+        # Attach user information to the trace
+        #
+        # @param trace [TraceOperation] Trace to attach data to. Defaults to
+        #   active trace.
+        # @param span [SpanOperation] Span to attach data to. Defaults to
+        #   active span on trace. Note that this should be a service entry span.
+        #   When AppSec is enabled, the expected span and trace are automatically
+        #   used as defaults.
+        # @param id [String] Mandatory. Username or client id extracted
+        #   from the access token or Authorization header in the inbound request
+        #   from outside the system.
+        # @param email [String] Email of the authenticated user associated
+        #   to the trace.
+        # @param name [String] User-friendly name. To be displayed in the
+        #   UI if set.
+        # @param session_id [String] Session ID of the authenticated user.
+        # @param role [String] Actual/assumed role the client is making
+        #   the request under extracted from token or application security
+        #   context.
+        # @param scope [String] Scopes or granted authorities the client
+        #   currently possesses extracted from token or application security
+        #   context. The value would come from the scope associated with an OAuth
+        #   2.0 Access Token or an attribute value in a SAML 2.0 Assertion.
+        # @param others [Hash<Symbol, String>] Additional free-form
+        #   user information to attach to the trace.
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def set_user(
+          trace = nil, span = nil, id:, email: nil, name: nil, session_id: nil, role: nil, scope: nil, **others
+        )
+          raise ArgumentError, 'missing required key: :id' if id.nil?
+
+          # enforce types
+
+          raise TypeError, ':id must be a String'         unless id.is_a?(String)
+          raise TypeError, ':email must be a String'      unless email.nil? || email.is_a?(String)
+          raise TypeError, ':name must be a String'       unless name.nil? || name.is_a?(String)
+          raise TypeError, ':session_id must be a String' unless session_id.nil? || session_id.is_a?(String)
+          raise TypeError, ':role must be a String'       unless role.nil? || role.is_a?(String)
+          raise TypeError, ':scope must be a String'      unless scope.nil? || scope.is_a?(String)
+
+          others.each do |k, v|
+            raise TypeError, "#{k.inspect} must be a String" unless v.nil? || v.is_a?(String)
+          end
+
+          set_trace_and_span_context('set_user', trace, span) do |_active_trace, active_span|
+            # set tags once data is known consistent
+            active_span.set_tag('usr.id', id)
+            active_span.set_tag('usr.email', email)           unless email.nil?
+            active_span.set_tag('usr.name', name)             unless name.nil?
+            active_span.set_tag('usr.session_id', session_id) unless session_id.nil?
+            active_span.set_tag('usr.role', role)             unless role.nil?
+            active_span.set_tag('usr.scope', scope)           unless scope.nil?
+
+            others.each do |k, v|
+              active_span.set_tag("usr.#{k}", v) unless v.nil?
+            end
+
+            if Datadog::AppSec.active_scope
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+          end
+        end
+        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        private
+
+        def set_trace_and_span_context(method, trace = nil, span = nil)
+          if (appsec_scope = Datadog::AppSec.active_scope)
+            trace = appsec_scope.trace
+            span = appsec_scope.service_entry_span
+          end
+
+          trace ||= Datadog::Tracing.active_trace
+          span ||= trace && trace.active_span || Datadog::Tracing.active_span
+
+          unless trace && span
+            Datadog.logger.debug(
+              "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+              ' to track this events'
+            )
+            return
+          end
+
+          raise ArgumentError, "span #{span.id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+
+          yield(trace, span)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/kit.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Datadog
+  # Datadog::Kit holds public-facing APIs for higher level user-facing
+  # features, these features not belonging to a specific product. Contrary to
+  # Datadog::Core, Kit depends on products.
+  module Kit
+  end
+end
+
+require_relative 'kit/identity'

data/lib/datadog/opentelemetry/api/context.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative 'trace/span'
+require_relative '../../tracing/trace_operation'
+require_relative '../trace'
+
+module Datadog
+  module OpenTelemetry
+    module API
+      # The OpenTelemetry Context contains a key-value store that can be attached
+      # to a trace.
+      #
+      # It loosely matches our `TraceOperations#tags`, except for the following:
+      # * Context can store arbitrary objects as values. One example is for the key
+      #   `Context::Key.new('current-span')`, which is associated with a `Span` object.
+      #   In contrast, `TraceOperations#tags` only stores string values.
+      # * Context is how spans know who their parent span is. The parenting operation happens on every
+      #   span created. Parenting is not directly tied to the active Fiber or Thread.
+      # * Context is immutable: changing a value creates a copy of Context.
+      # * Context is not bound to a specific trace: it can be reused an arbitrary number of times.
+      module Context
+        CURRENT_SPAN_KEY = ::OpenTelemetry::Trace.const_get(:CURRENT_SPAN_KEY)
+        private_constant :CURRENT_SPAN_KEY
+
+        def initialize(entries, trace: nil)
+          @trace = trace || ::Datadog::Tracing.send(:tracer).send(:start_trace)
+          @trace.otel_values.merge!(entries) if entries
+          @trace.otel_context ||= self
+        end
+
+        # Because Context can be reused, we have to make sure we have
+        # a valid `TraceOperation` on every invocation.
+        def ensure_trace
+          return nil unless @trace
+
+          # The Context can be reused after the root span has finished.
+          @trace.send(:reset) if @trace.finished?
+          @trace
+        end
+
+        # Returns the corresponding value (or nil) for key
+        #
+        # @param [Key] key The lookup key
+        # @return [Object]
+        def value(key)
+          return nil unless @trace
+
+          @trace.otel_value(key)
+        end
+
+        alias [] value
+
+        # Returns a new Context where entries contains the newly added key and value
+        #
+        # @param [Key] key The key to store this value under
+        # @param [Object] value Object to be stored under key
+        # @return [Context]
+        def set_value(key, value)
+          set_values(key => value)
+        end
+
+        # Returns a new Context with the current context's entries merged with the
+        #   new entries
+        #
+        # @param [Hash] values The values to be merged with the current context's
+        #   entries.
+        # @param [Object] value Object to be stored under key
+        # @return [Context]
+        def set_values(values)
+          if (current_span = values[CURRENT_SPAN_KEY]) && current_span.datadog_trace
+            # Because `#set_value` returns new context, we have to create
+            # a new copy of the active trace to ensure there's no conflict with
+            # other users of the active trace.
+            # It effectively becomes an internal trace propagation.
+            trace = Datadog::OpenTelemetry::Trace.start_trace_copy(
+              current_span.datadog_trace,
+              parent_span: current_span.datadog_span
+            )
+          end
+
+          existing_values = @trace && @trace.otel_values || {}
+
+          ::OpenTelemetry::Context.new(existing_values.merge(values), trace: trace)
+        end
+
+        # The Datadog {TraceOperation} associated with this {Context}.
+        def trace
+          @trace
+        end
+
+        # Singleton class methods for {Context}
+        module SingletonClass
+          # Returns current context, which is never nil
+          #
+          # @return [Context]
+          def current
+            trace = Tracing.active_trace
+            return ::OpenTelemetry::Context::ROOT unless trace
+
+            trace.otel_context ||= ::OpenTelemetry::Context.from_trace(trace)
+          end
+
+          # Associates a Context with the caller's current Fiber. Every call to
+          # this operation should be paired with a corresponding call to detach.
+          #
+          # Returns a token to be used with the matching call to detach
+          #
+          # @param [Context] context The new context
+          # @return [Object] A token to be used when detaching
+          def attach(context)
+            previous_trace = Tracing.active_trace
+            continue_trace!(context)
+
+            stack.push(previous_trace && previous_trace.otel_context || ::OpenTelemetry::Context::ROOT)
+            stack.size
+          end
+
+          # Restores the previous Context associated with the current Fiber.
+          # The supplied token is used to check if the call to detach is balanced
+          # with a corresponding attach call. A warning is logged if the
+          # calls are unbalanced.
+          #
+          # @param [Object] token The token provided by the matching call to attach
+          # @return [Boolean] True if the calls matched, false otherwise
+          def detach(token)
+            s = stack
+            calls_matched = (token == s.size)
+            unless calls_matched
+              ::OpenTelemetry.handle_error(
+                exception: ::OpenTelemetry::Context::DetachError.new(
+                  'calls to detach should match corresponding calls to attach.'
+                )
+              )
+            end
+
+            previous_context = s.pop
+            continue_trace!(previous_context)
+            calls_matched
+          end
+
+          # Part of the OpenTelemetry public API for {Context}.
+          def clear
+            super
+            tracer = Tracing.send(:tracer)
+            tracer.send(:call_context).activate!(nil)
+          end
+
+          # Creates a new {Context} associated with a {TraceOperation}.
+          def from_trace(trace)
+            new({}, trace: trace)
+          end
+
+          private
+
+          def continue_trace!(context, &block)
+            call_context = Tracing.send(:tracer).send(:call_context)
+            if context && context.trace
+              call_context.activate!(context.ensure_trace, &block)
+            else
+              call_context.activate!(nil)
+            end
+          end
+        end
+
+        def self.prepended(base)
+          base.singleton_class.prepend(SingletonClass)
+        end
+
+        ::OpenTelemetry::Context.prepend(self)
+      end
+
+      # OpenTelemetry-specific {TraceOperation} features.
+      #
+      # These extensions providing matching between {TraceOperation}
+      # and OpenTelemetry {Context}.
+      module TraceOperation
+        attr_accessor :otel_context
+
+        # Stores values from Context#entries
+        def otel_value(key)
+          otel_values[key]
+        end
+
+        # Retrieves values for Context#entries
+        def otel_values
+          @otel_values ||= {}
+        end
+
+        Tracing::TraceOperation.include(self)
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/api/trace/span.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module Trace
+      # Stores associated Datadog entities to the OpenTelemetry Span.
+      module Span
+        attr_accessor :datadog_trace, :datadog_span
+
+        ::OpenTelemetry::Trace::Span.prepend(self)
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/configurator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'span_processor'
+require_relative 'id_generator'
+require_relative 'propagator'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      # The Configurator is responsible for setting wiring up
+      # different OpenTelemetry requirements together.
+      # Some of the requirements will be changed to Datadog versions.
+      module Configurator
+        def initialize
+          super
+          @id_generator = IdGenerator
+        end
+
+        # Ensure Datadog-configure propagation styles have are applied when configured.
+        #
+        # DEV: Support configuring propagation through the environment variable
+        # DEV: `OTEL_PROPAGATORS`, similar to `DD_TRACE_PROPAGATION*`?
+        def configure_propagation
+          @propagators = [Propagator.new(Tracing::Contrib::HTTP)]
+          super
+        end
+
+        # Ensure Datadog-configure trace writer is configured.
+        def wrapped_exporters_from_env
+          [SpanProcessor.new]
+        end
+
+        ::OpenTelemetry::SDK::Configurator.prepend(self)
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/id_generator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      # Generates Datadog-compatible IDs for OpenTelemetry traces.
+      # OpenTelemetry traces already produce Datadog-compatible IDs.
+      class IdGenerator
+        class << self
+          include ::OpenTelemetry::Trace
+
+          # Generates a valid trace identifier, a 16-byte string with at least one
+          # non-zero byte.
+          #
+          # @return [String] a valid trace ID.
+          def generate_trace_id
+            loop do
+              id = Random.bytes(8) # DEV: Change to 16 (16*8-byte) when 128-bit trace_id is supported.
+              return id unless id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
+            end
+          end
+        end
+      end
+    end
+  end
+end