ddtrace 0.35.2 → 1.1.0

data/lib/datadog/core/workers/runtime_metrics.rb

@@ -0,0 +1,62 @@
+# typed: false
+
+require 'datadog/core/runtime/metrics'
+
+require 'datadog/core/worker'
+require 'datadog/core/workers/async'
+require 'datadog/core/workers/polling'
+
+module Datadog
+  module Core
+    module Workers
+      # Emits runtime metrics asynchronously on a timed loop
+      class RuntimeMetrics < Worker
+        include Workers::Polling
+
+        # In seconds
+        DEFAULT_FLUSH_INTERVAL = 10
+        DEFAULT_BACK_OFF_MAX = 30
+
+        attr_reader \
+          :metrics
+
+        def initialize(options = {})
+          @metrics = options.fetch(:metrics) { Core::Runtime::Metrics.new }
+
+          # Workers::Async::Thread settings
+          self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)
+
+          # Workers::IntervalLoop settings
+          self.loop_base_interval = options.fetch(:interval, DEFAULT_FLUSH_INTERVAL)
+          self.loop_back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
+          self.loop_back_off_max = options.fetch(:back_off_max, DEFAULT_BACK_OFF_MAX)
+
+          self.enabled = options.fetch(:enabled, false)
+        end
+
+        def perform
+          metrics.flush
+          true
+        end
+
+        def register_service(service)
+          # Start the worker
+          metrics.register_service(service).tap { perform }
+        end
+
+        # TODO: `close_metrics` is only needed because
+        # Datadog::Core::Configuration::Components directly manipulates
+        # the lifecycle of Runtime::Metrics.statsd instances.
+        # This should be avoided, as it prevents this class from
+        # ensuring correct resource decommission of its internal
+        # dependencies.
+        def stop(*args, close_metrics: true)
+          self.enabled = false
+          result = super(*args)
+          @metrics.close if close_metrics
+          result
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core.rb

@@ -0,0 +1,80 @@
+# typed: strict
+
+# TODO: Move these requires to smaller modules.
+#       Would be better to lazy load these; not
+#       all of these components will be used in
+#       every application.
+# require 'datadog/core/buffer/cruby'
+# require 'datadog/core/buffer/random'
+# require 'datadog/core/buffer/thread_safe'
+# require 'datadog/core/chunker'
+# require 'datadog/core/configuration'
+# require 'datadog/core/diagnostics/environment_logger'
+# require 'datadog/core/diagnostics/ext'
+# require 'datadog/core/diagnostics/health'
+# require 'datadog/core/encoding'
+# require 'datadog/core/environment/cgroup'
+# require 'datadog/core/environment/class_count'
+# require 'datadog/core/environment/container'
+# require 'datadog/core/environment/ext'
+# require 'datadog/core/environment/gc'
+# require 'datadog/core/environment/identity'
+# require 'datadog/core/environment/socket'
+# require 'datadog/core/environment/thread_count'
+# require 'datadog/core/environment/variable_helpers'
+# require 'datadog/core/environment/vm_cache'
+# require 'datadog/core/error'
+# require 'datadog/core/event'
+# require 'datadog/core/git/ext'
+# require 'datadog/core/logger'
+# require 'datadog/core/metrics/client'
+# require 'datadog/core/metrics/ext'
+# require 'datadog/core/metrics/helpers'
+# require 'datadog/core/metrics/logging'
+# require 'datadog/core/metrics/metric'
+# require 'datadog/core/metrics/options'
+# require 'datadog/core/pin'
+# require 'datadog/core/quantization/hash'
+# require 'datadog/core/quantization/http'
+# require 'datadog/core/runtime/ext'
+# require 'datadog/core/runtime/metrics'
+# require 'datadog/core/utils'
+# require 'datadog/core/utils/compression'
+# require 'datadog/core/utils/database'
+# require 'datadog/core/utils/forking'
+# require 'datadog/core/utils/object_set'
+# require 'datadog/core/utils/only_once'
+# require 'datadog/core/utils/sequence'
+# require 'datadog/core/utils/string_table'
+# require 'datadog/core/utils/time'
+# require 'datadog/core/worker'
+# require 'datadog/core/workers/async'
+# require 'datadog/core/workers/interval_loop'
+# require 'datadog/core/workers/polling'
+# require 'datadog/core/workers/queue'
+# require 'datadog/core/workers/runtime_metrics'
+
+require 'datadog/core/extensions'
+
+# We must load core extensions to make certain global APIs
+# accessible: both for Datadog features and the core itself.
+module Datadog
+  # Common, lower level, internal code used (or usable) by two or more
+  # products. It is a dependency of each product. Contrast with Datadog::Kit
+  # for higher-level features.
+  module Core
+  end
+
+  extend Core::Extensions
+
+  # Add shutdown hook:
+  # Ensures the Datadog components have a chance to gracefully
+  # shut down and cleanup before terminating the process.
+  at_exit do
+    if Interrupt === $! # rubocop:disable Style/SpecialGlobalVars is process terminating due to a ctrl+c or similar?
+      Datadog.send(:handle_interrupt_shutdown!)
+    else
+      Datadog.shutdown!
+    end
+  end
+end

data/lib/datadog/kit/enable_core_dumps.rb

@@ -0,0 +1,50 @@
+# typed: ignore
+
+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
+
+        if maximum_size <= 0
+          Kernel.warn("[DDTRACE] Could not enable core dumps on crash, maximum size is #{maximum_size} (disabled).")
+          return
+        elsif maximum_size == current_size
+          Kernel.warn('[DDTRACE] Core dumps already enabled, nothing to do!')
+          return
+        end
+
+        begin
+          Process.setrlimit(:CORE, maximum_size)
+        rescue => e
+          Kernel.warn(
+            "[DDTRACE] Failed to enable core dumps. Cause: #{e.class.name} #{e.message} " \
+            "Location: #{Array(e.backtrace).first}"
+          )
+          return
+        end
+
+        if current_size == 0
+          Kernel.warn("[DDTRACE] Enabled core dumps. Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'")
+        else
+          Kernel.warn(
+            "[DDTRACE] Raised core dump limit. Old size: #{current_size} " \
+            "Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'"
+          )
+        end
+      end
+    end
+  end
+end
+
+Datadog::Kit::EnableCoreDumps.call

data/lib/datadog/kit/identity.rb

@@ -0,0 +1,63 @@
+# typed: false
+
+module Datadog
+  module Kit
+    # Tracking identity via traces
+    module Identity
+      # Attach user information to the trace
+      #
+      # @param trace [TraceOperation] Trace to attach data to.
+      # @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<String || Symbol, String>] Additional free-form
+      #   user information to attach to the trace.
+      #
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.set_user(trace, 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 tags once data is known consistent
+
+        trace.set_tag('usr.id', id)
+        trace.set_tag('usr.email', email)           unless email.nil?
+        trace.set_tag('usr.name', name)             unless name.nil?
+        trace.set_tag('usr.session_id', session_id) unless session_id.nil?
+        trace.set_tag('usr.role', role)             unless role.nil?
+        trace.set_tag('usr.scope', scope)           unless scope.nil?
+
+        others.each do |k, v|
+          trace.set_tag("usr.#{k}", v) unless v.nil?
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end

data/lib/datadog/kit.rb

@@ -0,0 +1,11 @@
+# typed: false
+
+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 'datadog/kit/identity'

data/lib/datadog/opentracer/binary_propagator.rb

@@ -0,0 +1,26 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    module BinaryPropagator
+      extend Propagator
+
+      # Inject a SpanContext into the given carrier
+      #
+      # @param span_context [SpanContext]
+      # @param carrier [Carrier] A carrier object of Binary type
+      def self.inject(span_context, carrier)
+        nil
+      end
+
+      # Extract a SpanContext in Binary format from the given carrier.
+      #
+      # @param carrier [Carrier] A carrier object of Binary type
+      # @return [SpanContext, nil] the extracted SpanContext or nil if none could be found
+      def self.extract(carrier)
+        SpanContext::NOOP_INSTANCE
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/carrier.rb

@@ -0,0 +1,9 @@
+# typed: strict
+
+module Datadog
+  module OpenTracer
+    # @public_api
+    class Carrier < ::OpenTracing::Carrier
+    end
+  end
+end

data/lib/datadog/opentracer/distributed_headers.rb

@@ -0,0 +1,58 @@
+# typed: true
+
+require 'datadog/tracing/span'
+require 'datadog/tracing/distributed/headers/ext'
+
+module Datadog
+  module OpenTracer
+    # DistributedHeaders provides easy access and validation to headers
+    # @public_api
+    class DistributedHeaders
+      include Tracing::Distributed::Headers::Ext
+
+      def initialize(carrier)
+        @carrier = carrier
+      end
+
+      def valid?
+        # Sampling priority is optional.
+        !trace_id.nil? && !parent_id.nil?
+      end
+
+      def trace_id
+        id HTTP_HEADER_TRACE_ID
+      end
+
+      def parent_id
+        id HTTP_HEADER_PARENT_ID
+      end
+
+      def sampling_priority
+        hdr = @carrier[HTTP_HEADER_SAMPLING_PRIORITY]
+        # It's important to make a difference between no header,
+        # and a header defined to zero.
+        return unless hdr
+
+        value = hdr.to_i
+        return if value < 0
+
+        value
+      end
+
+      def origin
+        hdr = @carrier[HTTP_HEADER_ORIGIN]
+        # Only return the value if it is not an empty string
+        hdr if hdr != ''
+      end
+
+      private
+
+      def id(header)
+        value = @carrier[header].to_i
+        return if value.zero? || value >= Datadog::Tracing::Span::EXTERNAL_MAX_ID
+
+        value < 0 ? value + 0x1_0000_0000_0000_0000 : value
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/global_tracer.rb

@@ -0,0 +1,17 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # Patch for OpenTracing module
+    module GlobalTracer
+      def global_tracer=(tracer)
+        super.tap do
+          if tracer.class <= Datadog::OpenTracer::Tracer
+            # Update the Datadog global tracer, too.
+            Datadog.configure { |c| c.tracing.instance = tracer.datadog_tracer }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/propagator.rb

@@ -0,0 +1,26 @@
+# typed: false
+
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    # @abstract
+    # @public_api
+    module Propagator
+      # Inject a SpanContext into the given carrier
+      #
+      # @param span_context [SpanContext]
+      # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
+      def inject(span_context, carrier)
+        raise NotImplementedError
+      end
+
+      # Extract a SpanContext in the given format from the given carrier.
+      #
+      # @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(carrier)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/rack_propagator.rb

@@ -0,0 +1,72 @@
+# typed: true
+
+require 'datadog/tracing/context'
+require 'datadog/tracing/distributed/headers/ext'
+require 'datadog/tracing/propagation/http'
+require 'datadog/tracing/trace_operation'
+require 'datadog/opentracer/propagator'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    module RackPropagator
+      extend Propagator
+      extend Tracing::Distributed::Headers::Ext
+      include Tracing::Distributed::Headers::Ext
+
+      BAGGAGE_PREFIX = 'ot-baggage-'.freeze
+      BAGGAGE_PREFIX_FORMATTED = 'HTTP_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)
+          active_trace = span_context.datadog_context.active_trace
+
+          # Inject Datadog trace properties
+          Tracing::Propagation::HTTP.inject!(active_trace, carrier)
+
+          # Inject baggage
+          span_context.baggage.each do |key, value|
+            carrier[BAGGAGE_PREFIX + key] = value
+          end
+
+          nil
+        end
+
+        # Extract a SpanContext in Rack format from the given carrier.
+        #
+        # @param carrier [Carrier] A carrier object of Rack type
+        # @return [SpanContext, nil] the extracted SpanContext or nil if none could be found
+        def extract(carrier)
+          # First extract & build a Datadog context
+          datadog_trace_digest = Tracing::Propagation::HTTP.extract(carrier)
+
+          # Then extract any other baggage
+          baggage = {}
+          carrier.each do |key, value|
+            baggage[header_to_baggage(key)] = value if baggage_header?(key)
+          end
+
+          SpanContextFactory.build(
+            datadog_context: nil,
+            datadog_trace_digest: datadog_trace_digest,
+            baggage: baggage
+          )
+        end
+
+        private
+
+        def baggage_header?(header)
+          header.to_s.start_with?(BAGGAGE_PREFIX_FORMATTED)
+        end
+
+        def header_to_baggage(key)
+          key[BAGGAGE_PREFIX_FORMATTED.length, key.length].downcase
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/scope.rb

@@ -0,0 +1,18 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for scope
+    # @public_api
+    class Scope < ::OpenTracing::Scope
+      attr_reader \
+        :manager,
+        :span
+
+      def initialize(manager:, span:)
+        @manager = manager
+        @span = span
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/scope_manager.rb

@@ -0,0 +1,9 @@
+# typed: strict
+
+module Datadog
+  module OpenTracer
+    # @public_api
+    class ScopeManager < ::OpenTracing::ScopeManager
+    end
+  end
+end

data/lib/datadog/opentracer/span.rb

@@ -0,0 +1,101 @@
+# typed: true
+
+require 'time'
+
+require 'datadog/tracing/metadata/ext'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for Datadog::Span
+    # @public_api
+    class Span < ::OpenTracing::Span
+      attr_reader \
+        :datadog_span
+
+      def initialize(datadog_span:, span_context:)
+        @datadog_span = datadog_span
+        @span_context = span_context
+      end
+
+      # Set the name of the operation
+      #
+      # @param [String] name
+      def operation_name=(name)
+        datadog_span.name = name
+      end
+
+      # Span Context
+      #
+      # @return [SpanContext]
+      def context
+        @span_context
+      end
+
+      # Set a tag value on this span
+      # @param key [String] the key of the tag
+      # @param value [String, Numeric, Boolean] the value of the tag. If it's not
+      # a String, Numeric, or Boolean it will be encoded with to_s
+      def set_tag(key, value)
+        # Special cases to convert opentracing tags to datadog tags
+        case key
+        when 'error'
+          # Opentracing supports and `error: <bool>` tag, we need to convert to span status
+          # DEV: Do not return, we want to still set the `error` tag as they requested
+          datadog_span.status = value ? Datadog::Tracing::Metadata::Ext::Errors::STATUS : 0
+        end
+
+        tap { datadog_span.set_tag(key, value) }
+      end
+
+      # Set a baggage item on the span
+      # @param key [String] the key of the baggage item
+      # @param value [String] the value of the baggage item
+      def set_baggage_item(key, value)
+        tap do
+          # SpanContext is immutable, so to make changes
+          # build a new span context.
+          @span_context = SpanContextFactory.clone(
+            span_context: context,
+            baggage: { key => value }
+          )
+        end
+      end
+
+      # Get a baggage item
+      # @param key [String] the key of the baggage item
+      # @return [String] value of the baggage item
+      def get_baggage_item(key)
+        context.baggage[key]
+      end
+
+      # @deprecated Use {#log_kv} instead.
+      # Reason: event is an optional standard log field defined in spec and not required.  Also,
+      # method name {#log_kv} is more consistent with other language implementations such as Python and Go.
+      #
+      # Add a log entry to this span
+      # @param event [String] event name for the log
+      # @param timestamp [Time] time of the log
+      # @param fields [Hash] Additional information to log
+      def log(event: nil, timestamp: Time.now, **fields)
+        super # Log deprecation warning
+
+        # If the fields specify an error
+        datadog_span.set_error(fields[:'error.object']) if fields.key?(:'error.object')
+      end
+
+      # Add a log entry to this span
+      # @param timestamp [Time] time of the log
+      # @param fields [Hash] Additional information to log
+      def log_kv(timestamp: Time.now, **fields)
+        # If the fields specify an error
+        datadog_span.set_error(fields[:'error.object']) if fields.key?(:'error.object')
+      end
+
+      # Finish the {Span}
+      # @param end_time [Time] custom end time, if not now
+      def finish(end_time: Time.now)
+        datadog_span.finish(end_time)
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/span_context.rb

@@ -0,0 +1,19 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for SpanContext
+    # @public_api
+    class SpanContext < ::OpenTracing::SpanContext
+      attr_reader \
+        :datadog_context,
+        :datadog_trace_digest
+
+      def initialize(datadog_context:, datadog_trace_digest: nil, baggage: {})
+        @datadog_context = datadog_context
+        @datadog_trace_digest = datadog_trace_digest
+        @baggage = baggage.freeze
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/span_context_factory.rb

@@ -0,0 +1,27 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # Creates new Datadog::OpenTracer::SpanContext
+    module SpanContextFactory
+      module_function
+
+      def build(datadog_context:, datadog_trace_digest: nil, baggage: {})
+        SpanContext.new(
+          datadog_context: datadog_context,
+          datadog_trace_digest: datadog_trace_digest,
+          baggage: baggage.dup
+        )
+      end
+
+      def clone(span_context:, baggage: {})
+        SpanContext.new(
+          datadog_context: span_context.datadog_context,
+          datadog_trace_digest: span_context.datadog_trace_digest,
+          # Merge baggage from previous SpanContext
+          baggage: span_context.baggage.merge(baggage)
+        )
+      end
+    end
+  end
+end