datadog 2.0.0.beta1

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      # Compatibility wrapper to allow Datadog propagators to fulfill the
+      # OpenTelemetry propagator API.
+      class Propagator
+        def initialize(datadog_propagator)
+          @datadog_propagator = datadog_propagator
+        end
+
+        def inject(
+          carrier, context: ::OpenTelemetry::Context.current,
+          setter: ::OpenTelemetry::Context::Propagation.text_map_setter
+        )
+          unless setter == ::OpenTelemetry::Context::Propagation.text_map_setter
+            Datadog.logger.error(
+              'Custom setter is not supported. Please inform the `datadog` team at ' \
+            ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
+            'OpenTelemetry::Context::Propagation.text_map_setter as a fallback setter.'
+            )
+          end
+
+          @datadog_propagator.inject(context.trace.to_digest, carrier)
+        end
+
+        def extract(
+          carrier, context: ::OpenTelemetry::Context.current,
+          getter: ::OpenTelemetry::Context::Propagation.text_map_getter
+        )
+          if getter != ::OpenTelemetry::Context::Propagation.text_map_getter &&
+              getter != ::OpenTelemetry::Common::Propagation.rack_env_getter
+            Datadog.logger.error(
+              "Custom getter #{getter} is not supported. Please inform the `datadog` team at " \
+            ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
+            'OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter.'
+            )
+          end
+
+          digest = @datadog_propagator.extract(carrier)
+          return context unless digest
+
+          trace_id = to_otel_id(digest.trace_id)
+          span_id = to_otel_id(digest.span_id)
+
+          if digest.trace_state || digest.trace_flags
+            trace_flags = ::OpenTelemetry::Trace::TraceFlags.from_byte(digest.trace_flags)
+            tracestate = Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_tracestate, digest)
+          else
+            trace_flags = if Tracing::Sampling::PrioritySampler.sampled?(digest.trace_sampling_priority)
+                            ::OpenTelemetry::Trace::TraceFlags::SAMPLED
+                          else
+                            ::OpenTelemetry::Trace::TraceFlags::DEFAULT
+                          end
+            tracestate = ::OpenTelemetry::Trace::Tracestate::DEFAULT
+          end
+
+          span_context = ::OpenTelemetry::Trace::SpanContext.new(
+            trace_id: trace_id,
+            span_id: span_id,
+            trace_flags: trace_flags,
+            tracestate: tracestate,
+            remote: true
+          )
+
+          span = ::OpenTelemetry::Trace.non_recording_span(span_context)
+
+          trace = Tracing.continue_trace!(digest)
+
+          span.datadog_trace = trace
+
+          ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)
+        end
+
+        # Returns fields set by this propagator.
+        # DEV: Doesn't seem like it's used in production Otel code paths.
+        def fields
+          []
+        end
+
+        private
+
+        # Converts the {Numeric} Datadog id object to OpenTelemetry's byte array format.
+        # This method currently converts an unsigned 64-bit Integer to a binary String.
+        def to_otel_id(dd_id)
+          Array(dd_id).pack('Q')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'trace/span'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      # Keeps OpenTelemetry spans in sync with the Datadog execution context.
+      # Also responsible for flushing spans when their are finished.
+      class SpanProcessor
+        # Called when a {Span} is started, if the {Span#recording?}
+        # returns true.
+        #
+        # This method is called synchronously on the execution thread, should
+        # not throw or block the execution thread.
+        #
+        # @param [Span] span the {Span} that just started.
+        # @param [Context] parent_context the parent {Context} of the newly
+        #  started span.
+        def on_start(span, parent_context)
+          create_matching_datadog_span(span, parent_context)
+        end
+
+        # Called when a {Span} is ended, if the {Span#recording?}
+        # returns true.
+        #
+        # This method is called synchronously on the execution thread, should
+        # not throw or block the execution thread.
+        #
+        # @param [Span] span the {Span} that just ended.
+        def on_finish(span)
+          span.datadog_span.finish(ns_to_time(span.end_timestamp))
+        end
+
+        # Export all ended spans to the configured `Exporter` that have not yet
+        # been exported.
+        #
+        # This method should only be called in cases where it is absolutely
+        # necessary, such as when using some FaaS providers that may suspend
+        # the process after an invocation, but before the `Processor` exports
+        # the completed spans.
+        #
+        # @param [optional Numeric] timeout An optional timeout in seconds.
+        # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+        #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+        def force_flush(timeout: nil)
+          writer.force_flush(timeout: timeout) if writer.respond_to? :force_flush
+          Export::SUCCESS
+        end
+
+        # Called when {TracerProvider#shutdown} is called.
+        #
+        # @param [optional Numeric] timeout An optional timeout in seconds.
+        # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+        #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+        def shutdown(timeout: nil)
+          writer.stop
+          Export::SUCCESS
+        end
+
+        private
+
+        def writer
+          Datadog.configuration.tracing.writer
+        end
+
+        def create_matching_datadog_span(span, parent_context)
+          if parent_context.trace
+            Tracing.send(:tracer).send(:call_context).activate!(parent_context.ensure_trace)
+          else
+            Tracing.continue_trace!(nil)
+          end
+
+          datadog_span = start_datadog_span(span)
+
+          span.datadog_span = datadog_span
+          span.datadog_trace = Tracing.active_trace
+        end
+
+        def start_datadog_span(span)
+          attributes = span.attributes.dup # Dup to allow modification of frozen Hash
+
+          name, kwargs = span_arguments(span, attributes)
+
+          datadog_span = Tracing.trace(name, **kwargs)
+
+          datadog_span.set_error([nil, span.status.description]) unless span.status.ok?
+          datadog_span.set_tags(span.attributes)
+
+          datadog_span
+        end
+
+        # Some special attributes can override Datadog Span fields
+        def span_arguments(span, attributes)
+          if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
+          end
+          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
+
+          kwargs = { start_time: ns_to_time(span.start_timestamp) }
+
+          name = if attributes.key?('operation.name')
+                   attributes['operation.name']
+                 elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
+                   rich_name.downcase
+                 else
+                   span.kind
+                 end
+
+          kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
+          kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')
+          kwargs[:type] = attributes['span.type'] if attributes.key?('span.type')
+
+          attributes.reject! { |key, _| OpenTelemetry::Trace::Span::DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(key) }
+
+          # DEV: There's no `flat_map!`; we have to split it into two operations
+          attributes = attributes.map do |key, value|
+            Datadog::OpenTelemetry::Trace::Span.serialize_attribute(key, value)
+          end
+          attributes.flatten!(1)
+
+          kwargs[:tags] = attributes
+
+          [name, kwargs]
+        end
+
+        # From nanoseconds, used by OpenTelemetry, to a {Time} object, used by the Datadog Tracer.
+        def ns_to_time(timestamp_ns)
+          Time.at(timestamp_ns / 1000000000.0)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module Trace
+      # Stores associated Datadog entities to the OpenTelemetry Span.
+      module Span
+        # Attributes are equivalent to span tags and metrics.
+        def set_attribute(key, value)
+          res = super
+          # Attributes can get dropped or their values truncated by `super`
+          datadog_set_attribute(key)
+          res
+        end
+
+        # `alias` performed to match {OpenTelemetry::SDK::Trace::Span} aliasing upstream
+        alias []= set_attribute
+
+        # Attributes are equivalent to span tags and metrics.
+        def add_attributes(attributes)
+          res = super
+          # Attributes can get dropped or their values truncated by `super`
+          attributes.each { |key, _| datadog_set_attribute(key) }
+          res
+        end
+
+        # Captures changes to span error state.
+        def status=(s)
+          super
+
+          return unless status # Return if status are currently disabled by OpenTelemetry.
+          return unless (span = datadog_span)
+
+          # Status code can only change into an error state.
+          # Other change operations should be ignored.
+          span.set_error(status.description) if status && status.code == ::OpenTelemetry::Trace::Status::ERROR
+        end
+
+        # Serialize values into Datadog span tags and metrics.
+        # Notably, arrays are exploded into many keys, each with
+        # a numeric suffix representing the array index, for example:
+        # `'foo' => ['a','b']` becomes `'foo.0' => 'a', 'foo.1' => 'b'`
+        def self.serialize_attribute(key, value)
+          if value.is_a?(Array)
+            value.flat_map.with_index do |v, idx|
+              serialize_attribute("#{key}.#{idx}", v)
+            end
+          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            [[key, value.to_s]]
+          else
+            [[key, value]]
+          end
+        end
+
+        # Create a meaningful Datadog operation name from the OpenTelemetry
+        # semantic convention for span kind and span attributes.
+        # @see https://opentelemetry.io/docs/specs/semconv/general/trace/
+
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def self.enrich_name(kind, attrs)
+          if attrs.key?('http.request.method')
+            return 'http.server.request' if kind == :server
+            return 'http.client.request' if kind == :client
+          end
+
+          return "#{attrs['db.system']}.query" if attrs.key?('db.system') && kind == :client
+
+          if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
+              [:consumer, :producer, :server, :client].include?(kind)
+
+            return "#{attrs['messaging.system']}.#{attrs['messaging.operation']}"
+          end
+
+          if attrs.key?('rpc.system')
+            if attrs['rpc.system'] == 'aws-api' && kind == :client
+              service = attrs['rpc.service']
+              return "aws.#{service || 'client'}.request"
+            end
+
+            if kind == :client
+              return "#{attrs['rpc.system']}.client.request"
+            elsif kind == :server
+              return "#{attrs['rpc.system']}.server.request"
+            end
+          end
+
+          if attrs.key?('faas.invoked_provider') && attrs.key?('faas.invoked_name') && kind == :client
+            provider = attrs['faas.invoked_provider']
+            name = attrs['faas.invoked_name']
+            return "#{provider}.#{name}.invoke"
+          end
+
+          return "#{attrs['faas.trigger']}.invoke" if attrs.key?('faas.trigger') && kind == :server
+
+          return 'graphql.server.request' if attrs.key?('graphql.operation.type')
+
+          if kind == :server
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.server.request" : 'server.request'
+          end
+
+          if kind == :client
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.client.request" : 'client.request'
+          end
+
+          kind.to_s
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
+        private
+
+        def datadog_set_attribute(key)
+          # Return if attributes are currently disabled by OpenTelemetry.
+          return unless defined?(@attributes) && @attributes
+          return unless (span = datadog_span)
+
+          # DEV: Accesses `@attributes` directly, since using `#attributes`
+          # DEV: clones the hash, causing unnecessary overhead.
+          if @attributes.key?(key)
+            # Try to find a richer operation name, unless an explicit override was provided.
+            if !@attributes.key?('operation.name') && (rich_name = Span.enrich_name(kind, @attributes))
+              span.name = rich_name.downcase
+            end
+
+            Span.serialize_attribute(key, @attributes[key]).each do |new_key, value|
+              override_datadog_values(span, new_key, value)
+
+              # When an attribute is used to override a Datadog Span property,
+              # it should NOT be set as a Datadog Span tag.
+              span.set_tag(new_key, value) unless DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(new_key)
+            end
+          else
+            span.clear_tag(key)
+
+            if key == 'service.name'
+              # By removing the service name, we set it to the fallback default,
+              # effectively removing the `service` attribute from OpenTelemetry's perspective.
+              span.service = Datadog.send(:components).tracer.default_service
+            end
+          end
+        end
+
+        # Some special attributes can override Datadog Span fields beyond tags and metrics.
+        # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
+        def override_datadog_values(span, key, value)
+          span.name = value if key == 'operation.name'
+          span.resource = value if key == 'resource.name'
+          span.service = value if key == 'service.name'
+          span.type = value if key == 'span.type'
+
+          if key == 'analytics.event' && value.respond_to?(:casecmp)
+            Datadog::Tracing::Analytics.set_sample_rate(
+              span,
+              value.casecmp('true') == 0 ? 1 : 0
+            )
+          end
+        end
+
+        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
+                                            'span.type'].freeze
+
+        ::OpenTelemetry::SDK::Trace::Span.prepend(self)
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/trace.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../tracing/trace_digest'
+
+module Datadog
+  module OpenTelemetry
+    # OpenTelemetry utilities related to the respective Datadog trace.
+    module Trace
+      class << self
+        # Creates a new TraceOperation object that can be attached to a new
+        # OpenTelemetry span.
+        # If `parent_span` is provided, then that span is set as the currently
+        # active parent span.
+        #
+        # @return [TraceOperation]
+        def start_trace_copy(trace, parent_span: nil)
+          digest = if parent_span
+                     digest_with_parent_span(trace, parent_span)
+                   else
+                     trace.to_digest
+                   end
+
+          # Create a new TraceOperation, attached to the current Datadog Tracer.
+          Datadog::Tracing.continue_trace!(digest)
+        end
+
+        private
+
+        # Creates a TraceDigest with the active span modified.
+        # This supports the implementation of `OpenTelemetry::Trace.context_with_span`,
+        # which allows you to specific any span as the arbitrary parent of a new span.
+        def digest_with_parent_span(trace, parent_span)
+          digest = trace.to_digest
+
+          Tracing::TraceDigest.new(
+            span_id: parent_span.id,
+            span_name: parent_span.name,
+            span_resource: parent_span.resource,
+            span_service: parent_span.service,
+            span_type: parent_span.type,
+            trace_distributed_tags: digest.trace_distributed_tags,
+            trace_hostname: digest.trace_hostname,
+            trace_id: digest.trace_id,
+            trace_name: digest.trace_name,
+            trace_origin: digest.trace_origin,
+            trace_process_id: digest.trace_process_id,
+            trace_resource: digest.trace_resource,
+            trace_runtime_id: digest.trace_runtime_id,
+            trace_sampling_priority: digest.trace_sampling_priority,
+            trace_service: digest.trace_service,
+            trace_state: digest.trace_state,
+            trace_state_unknown_fields: digest.trace_state_unknown_fields,
+            span_remote: digest.span_remote,
+          ).freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Entrypoint file for OpenTelemetry integration.
+#
+# This file's path is part of the @public_api.
+#
+# OpenTelemetry includes metrics, tracing, logs, and profiling.
+# This file activates the integrations of all OpenTelemetry
+# components supported by Datadog.
+
+# Load Tracing
+require_relative 'tracing'
+require_relative 'tracing/contrib'
+
+require_relative 'opentelemetry/api/context'
+
+# DEV: Should this be a Contrib integration, that depends on the `opentelemetry-sdk`
+# DEV: and checks for compatibility?
+# DEV: This is different from our existing OpenTracer API, but there are many safety
+# DEV: features built into Contrib instrumentation today.
+require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
+require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
+
+module Datadog
+  # Datadog OpenTelemetry integration.
+  module OpenTelemetry
+    # Used by Telemetry to decide if OpenTelemetry instrumentation is enabled
+    LOADED = true
+
+    # Use `Datadog.logger` as the default logger
+    def logger
+      @logger ||= ::Datadog.logger
+    end
+
+    ::OpenTelemetry.singleton_class.prepend(self)
+  end
+end
+
+# OpenTelemetry does not wait until the "root" span is finished to flush:
+# the "root" span does not have special influence on flushing order.
+#
+# The "root" OpenTelemetry span might be a span that is never finished, but
+# instead a placeholder for distributed tracing information, and ultimately gets discarded.
+# Consumers of the OpenTelemetry SpanProcessor pipeline are free to flush spans whenever
+# an individual span is finished.
+# Currently, this closely translates to Datadog's partial flushing.
+#
+# @see OpenTelemetry::SDK::Trace::SpanProcessor#on_finish
+Datadog.configure do |c|
+  c.tracing.partial_flush.enabled = true
+end

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'json'
+
+module Datadog
+  module Profiling
+    module Collectors
+      # Collects library metadata for loaded files ($LOADED_FEATURES) in the Ruby VM.
+      # The output of this class is a list of libraries which have been require'd (in particular, this is
+      # not a list of ALL installed libraries).
+      #
+      # This metadata powers grouping and categorization of stack trace data.
+      #
+      # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
+      class CodeProvenance
+        def initialize(standard_library_path: RbConfig::CONFIG.fetch('rubylibdir'))
+          @libraries_by_name = {}
+          @libraries_by_path = {}
+          @seen_files = Set.new
+          @seen_libraries = Set.new
+
+          record_library(
+            Library.new(
+              kind: 'standard library',
+              name: 'stdlib',
+              version: RUBY_VERSION,
+              path: standard_library_path,
+            )
+          )
+        end
+
+        def refresh(loaded_files: $LOADED_FEATURES, loaded_specs: Gem.loaded_specs.values)
+          record_loaded_specs(loaded_specs)
+          record_loaded_files(loaded_files)
+
+          self
+        end
+
+        def generate
+          seen_libraries
+        end
+
+        def generate_json
+          JSON.fast_generate(v1: seen_libraries.to_a)
+        end
+
+        private
+
+        attr_reader \
+          :libraries_by_name,
+          :libraries_by_path,
+          :seen_files,
+          :seen_libraries
+
+        def record_library(library)
+          libraries_by_name[library.name] = library
+          libraries_by_path[library.path] = library
+        end
+
+        # Ruby hash maps are guaranteed to keep the insertion order of keys. Here, we sort @libraries_by_path so
+        # that the hash can be iterated in reverse order of paths.
+        #
+        # Why we do this: We do this to make sure that if there are libraries with paths that are prefixes of other
+        # libraries, e.g. '/home/foo' and '/home/foo/bar', we match to the longest path first.
+        # When reverse sorting paths as strings, '/home/foo/bar' will come before '/home/foo'.
+        #
+        # This way, when we iterate the @libraries_by_path hash, we know the first hit will also be the longest.
+        #
+        # Alternatively/in the future we could instead use a trie to match paths, but I doubt for the data sizes we're
+        # looking at that a trie is that much faster than using Ruby's built-in native collections.
+        def sort_libraries_by_longest_path_first
+          @libraries_by_path = @libraries_by_path.sort.reverse!.to_h
+        end
+
+        def record_loaded_specs(loaded_specs)
+          recorded_library = false
+
+          loaded_specs.each do |spec|
+            next if libraries_by_name.key?(spec.name)
+
+            record_library(Library.new(kind: 'library', name: spec.name, version: spec.version, path: spec.gem_dir))
+            recorded_library = true
+          end
+
+          sort_libraries_by_longest_path_first if recorded_library
+        end
+
+        def record_loaded_files(loaded_files)
+          loaded_files.each do |file_path|
+            next if seen_files.include?(file_path)
+
+            seen_files << file_path
+
+            _, found_library = libraries_by_path.find { |library_path, _| file_path.start_with?(library_path) }
+            seen_libraries << found_library if found_library
+          end
+        end
+
+        Library = Struct.new(:kind, :name, :version, :path) do
+          def initialize(kind:, name:, version:, path:)
+            super(kind.freeze, name.dup.freeze, version.to_s.dup.freeze, path.dup.freeze)
+            freeze
+          end
+
+          def to_json(*args)
+            { kind: kind, name: name, version: version, paths: [path] }.to_json(*args)
+          end
+        end
+      end
+    end
+  end
+end