cw-datadog 2.23.0.2

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative 'trace/span'
+require_relative '../../tracing/span_link'
+require_relative '../../tracing/span_event'
+require_relative '../../tracing/trace_digest'
+
+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)
+          unless span.events.nil?
+            span.datadog_span.span_events = span.events.map do |event|
+              Datadog::Tracing::SpanEvent.new(
+                event.name,
+                attributes: event.attributes,
+                time_unix_nano: event.timestamp
+              )
+            end
+          end
+          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
+            otel_trace_id = span.context.hex_trace_id.to_i(16)
+            Tracing.continue_trace!(Datadog::Tracing::TraceDigest.new(trace_id: otel_trace_id, span_remote: false))
+          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)
+
+          unless span.links.nil?
+            datadog_span.links = span.links.map do |link|
+              Datadog::Tracing::SpanLink.new(
+                Datadog::Tracing::TraceDigest.new(
+                  trace_id: link.span_context.hex_trace_id.to_i(16),
+                  span_id: link.span_context.hex_span_id.to_i(16),
+                  trace_sampling_priority: (link.span_context.trace_flags&.sampled? ? 1 : 0),
+                  trace_state: link.span_context.tracestate&.to_s,
+                  span_remote: link.span_context.remote?,
+                ),
+                attributes: link.attributes
+              )
+            end
+          end
+
+          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
+
+          if attributes.key?('http.response.status_code')
+            attributes[Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE] = attributes.delete('http.response.status_code')
+          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::Tracing::Utils.serialize_attribute(key, value)
+          end
+          attributes.flatten!(1)
+
+          kwargs[:tags] = attributes.to_h
+
+          # DEV: The datadog span must have the same ID as the OpenTelemetry span
+          kwargs[:id] = span.context.hex_span_id.to_i(16)
+
+          [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,182 @@
+# frozen_string_literal: true
+
+require 'datadog/tracing/utils'
+
+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
+
+        # Record an exception during the execution of this span. Multiple exceptions
+        # can be recorded on a span.
+        #
+        # @param [Exception] exception The exception to recorded
+        # @param [optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
+        #   attributes One or more key:value pairs, where the keys must be
+        #   strings and the values may be (array of) string, boolean or numeric
+        #   type.
+        #
+        # @return [void]
+        def record_exception(exception, attributes: nil)
+          res = super
+          if (span = datadog_span)
+            # Sets the exception attributes as span error tags. The values in the attribute hash MUST
+            # take precedence over the type, message and stacktrace inferred from the exception object
+            type = attributes&.[]('exception.type') || exception.class.to_s
+            message = attributes&.[]('exception.message') || exception.message
+            stacktrace = attributes&.[]('exception.stacktrace') || exception.full_message(highlight: false, order: :top)
+            span.set_error_tags([type, message, stacktrace])
+          end
+          res
+        end
+
+        # `alias` performed to match {::OpenTelemetry::SDK::Trace::Span} aliasing upstream
+        alias []= set_attribute # rubocop:disable Style/Alias
+
+        # 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 { |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
+
+        # 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
+
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        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
+
+            Tracing::Utils.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
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
+        # 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
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        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
+
+          span.set_tag('http.status_code', value) if key == 'http.response.status_code'
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
+        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
+          'span.type', 'http.response.status_code'].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,52 @@
+# 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'
+require_relative 'opentelemetry/api/baggage'
+
+# 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
+      ::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,150 @@
+# 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"),
+          ruby_native_filename: Datadog::Profiling::Collectors::Stack._native_ruby_native_filename
+        )
+          @libraries_by_name = {}
+          @libraries_by_path = {}
+          @seen_files = Set.new
+          @seen_libraries = Set.new
+          @executable_paths = [Gem.bindir, (Bundler.bin_path.to_s if defined?(Bundler))].uniq.compact.freeze
+
+          record_library(
+            Library.new(
+              kind: "standard library",
+              name: "stdlib",
+              version: RUBY_VERSION,
+              path: standard_library_path,
+              extra_paths: [ruby_native_filename],
+            )
+          )
+        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_json
+          JSON.generate(v1: seen_libraries.to_a)
+        end
+
+        private
+
+        attr_reader \
+          :libraries_by_name,
+          :libraries_by_path,
+          :seen_files,
+          :seen_libraries,
+          :executable_paths
+
+        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)
+
+            extra_paths = [(spec.extension_dir if spec.extensions.any?)]
+            spec.executables&.each do |executable|
+              executable_paths.each do |path|
+                extra_paths << File.join(path, executable)
+              end
+            end
+
+            record_library(
+              Library.new(
+                kind: "library",
+                name: spec.name,
+                version: spec.version,
+                path: spec.gem_dir,
+                extra_paths: extra_paths,
+              )
+            )
+            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
+
+            # NOTE: Don't use .find, it allocates a lot more memory (see commit that added this note for details)
+            libraries_by_path.any? do |library_path, library|
+              seen_libraries << library if file_path.start_with?(library_path)
+            end
+          end
+        end
+
+        # Represents metadata we have for a ruby gem
+        #
+        # Important note: This class gets encoded to JSON with the built-in JSON gem. But, we've found that in some
+        # buggy cases, some Ruby gems monkey patch the built-in JSON gem and forget to call #to_json, and instead
+        # encode this class instance-field-by-instance-field.
+        #
+        # Thus, this class was setup to match the JSON output. Take this into consideration if you are adding new
+        # fields. (Also, we have a spec for this)
+        class Library
+          attr_reader :kind, :name, :version
+
+          def initialize(kind:, name:, version:, path:, extra_paths:)
+            extra_paths = Array(extra_paths).compact.reject(&:empty?).map { |p| p.dup.freeze }
+            @kind = kind.freeze
+            @name = name.dup.freeze
+            @version = version.to_s.dup.freeze
+            @paths = [path.dup.freeze, *extra_paths].freeze
+            freeze
+          end
+
+          def to_json(arg = nil)
+            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
+          end
+
+          def path
+            @paths.first
+          end
+        end
+      end
+    end
+  end
+end