ddtrace 0.35.2 → 1.1.0

data/lib/datadog/opentracer/text_map_propagator.rb

@@ -0,0 +1,87 @@
+# typed: true
+
+require 'datadog/tracing/context'
+require 'datadog/tracing/distributed/headers/ext'
+require 'datadog/tracing/trace_operation'
+require 'datadog/opentracer/propagator'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    module TextMapPropagator
+      extend Propagator
+      extend Tracing::Distributed::Headers::Ext
+      include Tracing::Distributed::Headers::Ext
+
+      BAGGAGE_PREFIX = 'ot-baggage-'.freeze
+
+      class << self
+        # Inject a SpanContext into the given carrier
+        #
+        # @param span_context [SpanContext]
+        # @param carrier [Carrier] A carrier object of Rack type
+        def inject(span_context, carrier)
+          # Inject baggage
+          span_context.baggage.each do |key, value|
+            carrier[BAGGAGE_PREFIX + key] = value
+          end
+
+          # Inject Datadog trace properties
+          active_trace = span_context.datadog_context.active_trace
+          digest = active_trace.to_digest if active_trace
+          return unless digest
+
+          carrier[HTTP_HEADER_ORIGIN] = digest.trace_origin
+          carrier[HTTP_HEADER_PARENT_ID] = digest.span_id
+          carrier[HTTP_HEADER_SAMPLING_PRIORITY] = digest.trace_sampling_priority
+          carrier[HTTP_HEADER_TRACE_ID] = digest.trace_id
+
+          nil
+        end
+
+        # Extract a SpanContext in TextMap format from the given carrier.
+        #
+        # @param carrier [Carrier] A carrier object of TextMap type
+        # @return [SpanContext, nil] the extracted SpanContext or nil if none could be found
+        def extract(carrier)
+          # First extract & build a Datadog context
+          headers = DistributedHeaders.new(carrier)
+          datadog_trace_digest = headers_to_trace_digest(headers)
+
+          # Then extract any other baggage
+          baggage = {}
+          carrier.each do |key, value|
+            baggage[item_to_baggage(key)] = value if baggage_item?(key)
+          end
+
+          SpanContextFactory.build(
+            datadog_context: nil,
+            datadog_trace_digest: datadog_trace_digest,
+            baggage: baggage
+          )
+        end
+
+        private
+
+        def headers_to_trace_digest(headers)
+          return unless headers.valid?
+
+          Datadog::Tracing::TraceDigest.new(
+            span_id: headers.parent_id,
+            trace_id: headers.trace_id,
+            trace_origin: headers.origin,
+            trace_sampling_priority: headers.sampling_priority
+          )
+        end
+
+        def baggage_item?(item)
+          item.to_s.start_with?(BAGGAGE_PREFIX)
+        end
+
+        def item_to_baggage(key)
+          key[BAGGAGE_PREFIX.length, key.length]
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/thread_local_scope.rb

@@ -0,0 +1,34 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for thread local scopes
+    # @public_api
+    class ThreadLocalScope < Scope
+      attr_reader \
+        :finish_on_close
+
+      def initialize(
+        manager:,
+        span:,
+        finish_on_close: true
+      )
+        super(manager: manager, span: span)
+        @finish_on_close = finish_on_close
+        @previous_scope = manager.active
+      end
+
+      # Mark the end of the active period for the current thread and Scope,
+      # updating the ScopeManager#active in the process.
+      #
+      # NOTE: Calling close more than once on a single Scope instance leads to
+      # undefined behavior.
+      def close
+        return unless equal?(manager.active)
+
+        span.finish if finish_on_close
+        manager.send(:set_scope, @previous_scope)
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/thread_local_scope_manager.rb

@@ -0,0 +1,43 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for thread local scope management
+    # @public_api
+    class ThreadLocalScopeManager < ScopeManager
+      # Make a span instance active.
+      #
+      # @param span [Span] the Span that should become active
+      # @param finish_on_close [Boolean] whether the Span should automatically be
+      #   finished when Scope#close is called
+      # @return [Scope] instance to control the end of the active period for the
+      #  Span. It is a programming error to neglect to call Scope#close on the
+      #  returned instance.
+      def activate(span, finish_on_close: true)
+        ThreadLocalScope.new(
+          manager: self,
+          span: span,
+          finish_on_close: finish_on_close
+        ).tap do |scope|
+          set_scope(scope)
+        end
+      end
+
+      # @return [Scope] the currently active Scope which can be used to access the
+      # currently active Span.
+      #
+      # If there is a non-null Scope, its wrapped Span becomes an implicit parent
+      # (as Reference#CHILD_OF) of any newly-created Span at Tracer#start_active_span
+      # or Tracer#start_span time.
+      def active
+        Thread.current[object_id.to_s]
+      end
+
+      private
+
+      def set_scope(scope)
+        Thread.current[object_id.to_s] = scope
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/tracer.rb

@@ -0,0 +1,212 @@
+# typed: false
+
+require 'time'
+
+require 'datadog/tracing/context'
+require 'datadog/tracing/tracer'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for Datadog::Tracer
+    # @public_api
+    class Tracer < ::OpenTracing::Tracer
+      # (see Datadog::Tracer)
+      # @return [Datadog::Tracer]
+      attr_reader \
+        :datadog_tracer
+
+      # (see Datadog::Tracer#initialize)
+      def initialize(**options)
+        super()
+        @datadog_tracer = Datadog::Tracing::Tracer.new(**options)
+      end
+
+      # @return [ScopeManager] the current ScopeManager.
+      def scope_manager
+        @scope_manager ||= ThreadLocalScopeManager.new
+      end
+
+      # Returns a newly started and activated {Scope}.
+      #
+      # If `scope_manager.active` is not nil, no explicit references
+      # are provided, and `ignore_active_scope` is false, then an inferred
+      # {https://www.rubydoc.info/gems/opentracing/0.5.0/OpenTracing/Reference OpenTracing::Reference#CHILD_OF}
+      # reference is created to the `scope_manager.active`'s
+      # {SpanContext} when {#start_active_span} is invoked.
+      #
+      # @param operation_name [String] The operation name for the Span
+      # @param child_of [SpanContext, Span] SpanContext that acts as a parent to
+      #   the newly-started Span. If a Span instance is provided, its
+      #   context is automatically substituted. See [OpenTracing::Reference] for more
+      #   information.
+      #   If specified, the `references` parameter must be omitted.
+      # @param references [Array<OpenTracing::Reference>] An array of reference
+      #   objects that identify one or more parent SpanContexts.
+      # @param start_time [Time] When the Span started, if not now
+      # @param tags [Hash] Tags to assign to the Span at start time
+      # @param ignore_active_scope [Boolean] whether to create an implicit
+      #   OpenTracing::Reference#CHILD_OF reference to the ScopeManager#active.
+      # @param finish_on_close [Boolean] whether span should automatically be
+      #   finished when Scope#close is called
+      # @yield [Scope] If an optional block is passed to start_active it will
+      #   yield the newly-started Scope. If `finish_on_close` is true then the
+      #   Span will be finished automatically after the block is executed.
+      # @return [Scope] The newly-started and activated Scope
+      def start_active_span(operation_name,
+                            child_of: nil,
+                            references: nil,
+                            start_time: Time.now,
+                            tags: nil,
+                            ignore_active_scope: false,
+                            finish_on_close: true)
+
+        # When meant to automatically determine the parent,
+        # Use the active scope first, otherwise fall back to any
+        # context generated by Datadog, so as to append to it and gain
+        # the benefit of any out-of-the-box tracing from Datadog preceding
+        # the OpenTracer::Tracer.
+        #
+        # We do this here instead of in #start_span because #start_span generates
+        # spans that are not assigned to a scope, a.k.a not supposed to be used by
+        # subsequent spans implicitly. By using the existing Datadog context, the span
+        # effectively ends up "assigned to a scope", by virtue of being added to the
+        # Context. Hence, it would behave more like an active span, which is why it
+        # should only be here.
+        unless child_of || ignore_active_scope
+          child_of = if scope_manager.active
+                       scope_manager.active.span.context
+                     else
+                       SpanContextFactory.build(datadog_context: datadog_tracer.send(:call_context))
+                     end
+        end
+
+        # Create the span, and auto-add it to the Datadog context.
+        span = start_span(
+          operation_name,
+          child_of: child_of,
+          references: references,
+          start_time: start_time,
+          tags: tags,
+          ignore_active_scope: ignore_active_scope
+        )
+
+        # Overwrite the tracer context with the OpenTracing managed context.
+        # This is mostly for the benefit of any out-of-the-box tracing from Datadog,
+        # such that spans generated by that tracing will be attached to the OpenTracer
+        # parent span.
+        datadog_tracer.provider.context = span.context.datadog_context
+
+        scope_manager.activate(span, finish_on_close: finish_on_close).tap do |scope|
+          if block_given?
+            begin
+              yield(scope)
+            ensure
+              scope.close
+            end
+          end
+        end
+      end
+
+      # Like {#start_active_span}, but the returned {Span} has not been registered via the
+      # {ScopeManager}.
+      #
+      # @param operation_name [String] The operation name for the Span
+      # @param child_of [SpanContext, Span] SpanContext that acts as a parent to
+      #   the newly-started Span. If a Span instance is provided, its
+      #   context is automatically substituted. See [Reference] for more
+      #   information.
+      #   If specified, the `references` parameter must be omitted.
+      # @param references [Array<Reference>] An array of reference
+      #   objects that identify one or more parent SpanContexts.
+      # @param start_time [Time] When the Span started, if not now
+      # @param tags [Hash] Tags to assign to the Span at start time
+      # @param ignore_active_scope [Boolean] whether to create an implicit
+      #   References#CHILD_OF reference to the ScopeManager#active.
+      # @return [Span] the newly-started Span instance, which has not been
+      #   automatically registered via the ScopeManager
+      def start_span(operation_name,
+                     child_of: nil,
+                     references: nil,
+                     start_time: Time.now,
+                     tags: nil,
+                     ignore_active_scope: false)
+
+        # Derive the OpenTracer::SpanContext to inherit from.
+        parent_span_context = inherited_span_context(child_of, ignore_active_scope: ignore_active_scope)
+
+        # Retrieve Datadog::Context from parent SpanContext.
+        datadog_context = parent_span_context.nil? ? Datadog::Tracing::Context.new : parent_span_context.datadog_context
+        datadog_trace_digest = parent_span_context && parent_span_context.datadog_trace_digest
+
+        # Build the new Datadog span
+        datadog_span = datadog_tracer.trace(
+          operation_name,
+          continue_from: datadog_trace_digest,
+          _context: datadog_context,
+          start_time: start_time,
+          tags: tags || {}
+        )
+
+        # Build or extend the OpenTracer::SpanContext
+        span_context = if parent_span_context
+                         SpanContextFactory.clone(span_context: parent_span_context)
+                       else
+                         SpanContextFactory.build(datadog_context: datadog_context)
+                       end
+
+        # Wrap the Datadog span and OpenTracer::Span context in a OpenTracer::Span
+        Span.new(datadog_span: datadog_span, span_context: span_context)
+      end
+
+      # Inject a {SpanContext} into the given carrier.
+      #
+      # @param span_context [SpanContext]
+      # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
+      # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
+      def inject(span_context, format, carrier)
+        case format
+        when OpenTracing::FORMAT_TEXT_MAP
+          TextMapPropagator.inject(span_context, carrier)
+        when OpenTracing::FORMAT_BINARY
+          BinaryPropagator.inject(span_context, carrier)
+        when OpenTracing::FORMAT_RACK
+          RackPropagator.inject(span_context, carrier)
+        else
+          warn 'Unknown inject format'
+        end
+      end
+
+      # Extract a {SpanContext} in the given format from the given carrier.
+      #
+      # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
+      # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
+      # @return [SpanContext, nil] the extracted SpanContext or nil if none could be found
+      def extract(format, carrier)
+        case format
+        when OpenTracing::FORMAT_TEXT_MAP
+          TextMapPropagator.extract(carrier)
+        when OpenTracing::FORMAT_BINARY
+          BinaryPropagator.extract(carrier)
+        when OpenTracing::FORMAT_RACK
+          RackPropagator.extract(carrier)
+        else
+          warn 'Unknown extract format'
+          nil
+        end
+      end
+
+      private
+
+      def inherited_span_context(parent, ignore_active_scope: false)
+        case parent
+        when Span
+          parent.context
+        when SpanContext
+          parent
+        else
+          ignore_active_scope ? nil : scope_manager.active && scope_manager.active.span.context
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentracer.rb

@@ -0,0 +1,24 @@
+# typed: strict
+
+require 'opentracing'
+require 'opentracing/carrier'
+require 'datadog/tracing'
+
+require 'datadog/opentracer/carrier'
+require 'datadog/opentracer/tracer'
+require 'datadog/opentracer/span'
+require 'datadog/opentracer/span_context'
+require 'datadog/opentracer/span_context_factory'
+require 'datadog/opentracer/scope'
+require 'datadog/opentracer/scope_manager'
+require 'datadog/opentracer/thread_local_scope'
+require 'datadog/opentracer/thread_local_scope_manager'
+require 'datadog/opentracer/distributed_headers'
+require 'datadog/opentracer/propagator'
+require 'datadog/opentracer/text_map_propagator'
+require 'datadog/opentracer/binary_propagator'
+require 'datadog/opentracer/rack_propagator'
+require 'datadog/opentracer/global_tracer'
+
+# Modify the OpenTracing module functions
+::OpenTracing.singleton_class.prepend(Datadog::OpenTracer::GlobalTracer)

data/lib/datadog/profiling/backtrace_location.rb

@@ -0,0 +1,34 @@
+# typed: true
+
+module Datadog
+  module Profiling
+    # Entity class used to represent an entry in a stack trace.
+    # Its fields are a simplified struct version of `Thread::Backtrace::Location`.
+    class BacktraceLocation
+      attr_reader \
+        :base_label,
+        :lineno,
+        :path,
+        :hash
+
+      def initialize(
+        base_label,
+        lineno,
+        path
+      )
+        @base_label = base_label
+        @lineno = lineno
+        @path = path
+        @hash = [base_label, lineno, path].hash
+      end
+
+      def ==(other)
+        hash == other.hash
+      end
+
+      def eql?(other)
+        hash == other.hash
+      end
+    end
+  end
+end

data/lib/datadog/profiling/buffer.rb

@@ -0,0 +1,43 @@
+# typed: true
+
+require 'datadog/core/buffer/thread_safe'
+require 'datadog/core/utils/object_set'
+require 'datadog/core/utils/string_table'
+
+module Datadog
+  module Profiling
+    # Profiling buffer that stores profiling events. The buffer has a maximum size and when
+    # the buffer is full, a random event is discarded. This class is thread-safe.
+    class Buffer < Core::Buffer::ThreadSafe
+      def initialize(*args)
+        super
+        @caches = {}
+        @string_table = Core::Utils::StringTable.new
+      end
+
+      def cache(cache_name)
+        synchronize do
+          @caches[cache_name] ||= Core::Utils::ObjectSet.new
+        end
+      end
+
+      def string_table
+        synchronize do
+          @string_table
+        end
+      end
+
+      protected
+
+      def drain!
+        items = super
+
+        # Clear caches
+        @caches = {}
+        @string_table = Core::Utils::StringTable.new
+
+        items
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# typed: false
+
+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.
+      #
+      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