ddtrace 0.54.1 → 1.0.0.beta2

data/lib/ddtrace/forced_tracing.rb

@@ -1,39 +0,0 @@
-# typed: true
-require 'ddtrace/ext/manual_tracing'
-require 'ddtrace/ext/priority'
-
-module Datadog
-  # Defines analytics behavior
-  module ForcedTracing
-    class << self
-      def keep(span)
-        return if span.nil? || span.context.nil?
-
-        span.context.sampling_priority = Datadog::Ext::Priority::USER_KEEP
-      end
-
-      def drop(span)
-        return if span.nil? || span.context.nil?
-
-        span.context.sampling_priority = Datadog::Ext::Priority::USER_REJECT
-      end
-    end
-
-    # Extension for Datadog::Span
-    module Span
-      def set_tag(key, value)
-        # Configure sampling priority if they give us a forced tracing tag
-        # DEV: Do not set if the value they give us is explicitly "false"
-        case key
-        when Ext::ManualTracing::TAG_KEEP
-          ForcedTracing.keep(self) unless value == false
-        when Ext::ManualTracing::TAG_DROP
-          ForcedTracing.drop(self) unless value == false
-        else
-          # Otherwise, set the tag normally.
-          super if defined?(super)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/logger.rb

@@ -1,41 +0,0 @@
-# typed: true
-require 'logger'
-
-module Datadog
-  # A custom logger with minor enhancements:
-  # - progname defaults to ddtrace to clearly identify Datadog dd-trace-rb related messages
-  # - adds last caller stack-trace info to know where the message comes from
-  class Logger < ::Logger
-    PREFIX = 'ddtrace'.freeze
-
-    def initialize(*args, &block)
-      super
-      self.progname = PREFIX
-      self.level = ::Logger::INFO
-    end
-
-    def add(severity, message = nil, progname = nil, &block)
-      where = ''
-
-      # We are in debug mode, or this is an error, add stack trace to help debugging
-      if debug? || severity >= ::Logger::ERROR
-        c = caller
-        where = "(#{c[1]}) " if c.length > 1
-      end
-
-      if message.nil?
-        if block
-          super(severity, message, progname) do
-            "[#{self.progname}] #{where}#{yield}"
-          end
-        else
-          super(severity, message, "[#{self.progname}] #{where}#{progname}")
-        end
-      else
-        super(severity, "[#{self.progname}] #{where}#{message}")
-      end
-    end
-
-    alias log add
-  end
-end

data/lib/ddtrace/metrics.rb

@@ -1,282 +0,0 @@
-# typed: false
-require 'ddtrace/ext/metrics'
-
-require 'set'
-require 'logger'
-require 'datadog/core/environment/identity'
-require 'ddtrace/ext/environment'
-require 'ddtrace/utils/only_once'
-require 'ddtrace/utils/time'
-
-module Datadog
-  # Acts as client for sending metrics (via Statsd)
-  # Wraps a Statsd client with default tags and additional configuration.
-  class Metrics
-    attr_reader :statsd
-
-    def initialize(statsd: nil, enabled: true, **_)
-      @statsd =
-        if supported?
-          statsd || default_statsd_client
-        else
-          ignored_statsd_warning if statsd
-          nil
-        end
-      @enabled = enabled
-    end
-
-    def supported?
-      version = dogstatsd_version
-
-      !version.nil? && version >= Gem::Version.new('3.3.0') &&
-        # dogstatsd-ruby >= 5.0 & < 5.2.0 has known issues with process forks
-        # and do not support the single thread mode we use to avoid this problem.
-        !(version >= Gem::Version.new('5.0') && version < Gem::Version.new('5.3'))
-    end
-
-    def enabled?
-      @enabled
-    end
-
-    def enabled=(enabled)
-      @enabled = (enabled == true)
-    end
-
-    def default_hostname
-      ENV.fetch(Datadog::Ext::Metrics::ENV_DEFAULT_HOST, Datadog::Ext::Metrics::DEFAULT_HOST)
-    end
-
-    def default_port
-      ENV.fetch(Datadog::Ext::Metrics::ENV_DEFAULT_PORT, Datadog::Ext::Metrics::DEFAULT_PORT).to_i
-    end
-
-    def default_statsd_client
-      require 'datadog/statsd'
-
-      # Create a StatsD client that points to the agent.
-      #
-      # We use `single_thread: true`, as dogstatsd-ruby >= 5.0 creates a background thread
-      # by default, but does not handle forks correctly, causing resource leaks.
-      #
-      # Using dogstatsd-ruby >= 5.0 is still valuable, as it supports
-      # transparent batch metric submission, which reduces submission
-      # overhead.
-      #
-      # Versions < 5.0 are always single-threaded, but do not have the kwarg option.
-      options = if dogstatsd_version >= Gem::Version.new('5.2')
-                  { single_thread: true }
-                else
-                  {}
-                end
-
-      Datadog::Statsd.new(default_hostname, default_port, **options)
-    end
-
-    def configure(options = {})
-      @statsd = options[:statsd] if options.key?(:statsd)
-      self.enabled = options[:enabled] if options.key?(:enabled)
-    end
-
-    def send_stats?
-      enabled? && !statsd.nil?
-    end
-
-    def count(stat, value = nil, options = nil, &block)
-      return unless send_stats? && statsd.respond_to?(:count)
-
-      value, options = yield if block
-      raise ArgumentError if value.nil?
-
-      statsd.count(stat, value, metric_options(options))
-    rescue StandardError => e
-      Datadog.logger.error("Failed to send count stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
-    end
-
-    def distribution(stat, value = nil, options = nil, &block)
-      return unless send_stats? && statsd.respond_to?(:distribution)
-
-      value, options = yield if block
-      raise ArgumentError if value.nil?
-
-      statsd.distribution(stat, value, metric_options(options))
-    rescue StandardError => e
-      Datadog.logger.error("Failed to send distribution stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
-    end
-
-    def increment(stat, options = nil)
-      return unless send_stats? && statsd.respond_to?(:increment)
-
-      options = yield if block_given?
-
-      statsd.increment(stat, metric_options(options))
-    rescue StandardError => e
-      Datadog.logger.error("Failed to send increment stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
-    end
-
-    def gauge(stat, value = nil, options = nil, &block)
-      return unless send_stats? && statsd.respond_to?(:gauge)
-
-      value, options = yield if block
-      raise ArgumentError if value.nil?
-
-      statsd.gauge(stat, value, metric_options(options))
-    rescue StandardError => e
-      Datadog.logger.error("Failed to send gauge stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
-    end
-
-    def time(stat, options = nil)
-      return yield unless send_stats?
-
-      # Calculate time, send it as a distribution.
-      start = Utils::Time.get_time
-      yield
-    ensure
-      begin
-        if send_stats? && !start.nil?
-          finished = Utils::Time.get_time
-          distribution(stat, ((finished - start) * 1000), options)
-        end
-      rescue StandardError => e
-        Datadog.logger.error("Failed to send time stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
-      end
-    end
-
-    def send_metrics(metrics)
-      metrics.each { |m| send(m.type, *[m.name, m.value, m.options].compact) }
-    end
-
-    def close
-      @statsd.close if @statsd && @statsd.respond_to?(:close)
-    end
-
-    Metric = Struct.new(:type, :name, :value, :options) do
-      def initialize(*args)
-        super
-        self.options = options || {}
-      end
-    end
-
-    # For defining and adding default options to metrics
-    module Options
-      DEFAULT = {
-        tags: DEFAULT_TAGS = [
-          "#{Ext::Metrics::TAG_LANG}:#{Core::Environment::Identity.lang}".freeze,
-          "#{Ext::Metrics::TAG_LANG_INTERPRETER}:#{Core::Environment::Identity.lang_interpreter}".freeze,
-          "#{Ext::Metrics::TAG_LANG_VERSION}:#{Core::Environment::Identity.lang_version}".freeze,
-          "#{Ext::Metrics::TAG_TRACER_VERSION}:#{Core::Environment::Identity.tracer_version}".freeze
-        ].freeze
-      }.freeze
-
-      def metric_options(options = nil)
-        return default_metric_options if options.nil?
-
-        default_metric_options.merge(options) do |key, old_value, new_value|
-          case key
-          when :tags
-            old_value.dup.concat(new_value).uniq
-          else
-            new_value
-          end
-        end
-      end
-
-      def default_metric_options
-        # Return dupes, so that the constant isn't modified,
-        # and defaults are unfrozen for mutation in Statsd.
-        DEFAULT.dup.tap do |options|
-          options[:tags] = options[:tags].dup
-
-          env = Datadog.configuration.env
-          options[:tags] << "#{Datadog::Ext::Environment::TAG_ENV}:#{env}" unless env.nil?
-
-          version = Datadog.configuration.version
-          options[:tags] << "#{Datadog::Ext::Environment::TAG_VERSION}:#{version}" unless version.nil?
-        end
-      end
-    end
-
-    # For defining and adding helpers to metrics
-    module Helpers
-      [
-        :count,
-        :distribution,
-        :increment,
-        :gauge,
-        :time
-      ].each do |metric_type|
-        define_method(metric_type) do |name, stat|
-          name = name.to_sym
-          define_method(name) do |*args, &block|
-            send(metric_type, stat, *args, &block)
-          end
-        end
-      end
-    end
-
-    module Logging
-      # Surrogate for Datadog::Statsd to log elsewhere
-      class Adapter
-        attr_accessor :logger
-
-        def initialize(logger = nil)
-          @logger = logger || Logger.new($stdout).tap do |l|
-            l.level = Logger::INFO
-            l.progname = nil
-            l.formatter = proc do |_severity, datetime, _progname, msg|
-              stat = JSON.parse(msg[3..-1]) # Trim off leading progname...
-              "#{JSON.dump(timestamp: datetime.to_i, message: 'Metric sent.', metric: stat)}\n"
-            end
-          end
-        end
-
-        def count(stat, value, options = nil)
-          logger.info({ stat: stat, type: :count, value: value, options: options }.to_json)
-        end
-
-        def distribution(stat, value, options = nil)
-          logger.info({ stat: stat, type: :distribution, value: value, options: options }.to_json)
-        end
-
-        def increment(stat, options = nil)
-          logger.info({ stat: stat, type: :increment, options: options }.to_json)
-        end
-
-        def gauge(stat, value, options = nil)
-          logger.info({ stat: stat, type: :gauge, value: value, options: options }.to_json)
-        end
-      end
-    end
-
-    # Make available on for both class and instance.
-    include Options
-    extend Options
-    extend Helpers
-
-    private
-
-    def dogstatsd_version
-      return @dogstatsd_version if instance_variable_defined?(:@dogstatsd_version)
-
-      @dogstatsd_version = (
-        defined?(Datadog::Statsd::VERSION) &&
-          Datadog::Statsd::VERSION &&
-          Gem::Version.new(Datadog::Statsd::VERSION)
-      ) || (
-        Gem.loaded_specs['dogstatsd-ruby'] &&
-          Gem.loaded_specs['dogstatsd-ruby'].version
-      )
-    end
-
-    IGNORED_STATSD_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
-    private_constant :IGNORED_STATSD_ONLY_ONCE
-
-    def ignored_statsd_warning
-      IGNORED_STATSD_ONLY_ONCE.run do
-        Datadog.logger.warn(
-          'Ignoring user-supplied statsd instance as currently-installed version of dogstastd-ruby is incompatible. ' \
-          "To fix this, ensure that you have `gem 'dogstatsd-ruby', '~> 5.3'` on your Gemfile or gems.rb file."
-        )
-      end
-    end
-  end
-end

data/lib/ddtrace/opentelemetry/extensions.rb

@@ -1,14 +0,0 @@
-# typed: true
-require 'ddtrace/span'
-require 'ddtrace/opentelemetry/span'
-
-module Datadog
-  module OpenTelemetry
-    # Defines extensions to ddtrace for OpenTelemetry support
-    module Extensions
-      def self.extended(base)
-        Datadog::Span.prepend(OpenTelemetry::Span)
-      end
-    end
-  end
-end

data/lib/ddtrace/opentelemetry/span.rb

@@ -1,34 +0,0 @@
-# typed: false
-require 'ddtrace/ext/environment'
-
-module Datadog
-  module OpenTelemetry
-    # Extensions for Datadog::Span
-    module Span
-      TAG_SERVICE_NAME = 'service.name'.freeze
-      TAG_SERVICE_VERSION = 'service.version'.freeze
-
-      def set_tag(key, value)
-        # Configure sampling priority if they give us a forced tracing tag
-        # DEV: Do not set if the value they give us is explicitly "false"
-        case key
-        when TAG_SERVICE_NAME
-          if defined?(super)
-            # Set original tag and Datadog version tag
-            self.service = value
-            super
-          end
-        when TAG_SERVICE_VERSION
-          if defined?(super)
-            # Set original tag and Datadog version tag
-            super
-            super(Datadog::Ext::Environment::TAG_VERSION, value)
-          end
-        else
-          # Otherwise, set the tag normally.
-          super if defined?(super)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/opentracer/binary_propagator.rb

@@ -1,25 +0,0 @@
-# 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/ddtrace/opentracer/carrier.rb

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

data/lib/ddtrace/opentracer/distributed_headers.rb

@@ -1,56 +0,0 @@
-# typed: true
-require 'ddtrace/span'
-require 'ddtrace/ext/distributed'
-
-module Datadog
-  module OpenTracer
-    # DistributedHeaders provides easy access and validation to headers
-    class DistributedHeaders
-      include Datadog::Ext::DistributedTracing
-
-      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::Span::EXTERNAL_MAX_ID
-
-        value < 0 ? value + 0x1_0000_0000_0000_0000 : value
-      end
-    end
-  end
-end

data/lib/ddtrace/opentracer/global_tracer.rb

@@ -1,16 +0,0 @@
-# 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.tracer = tracer.datadog_tracer }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/opentracer/propagator.rb

@@ -1,23 +0,0 @@
-# typed: false
-module Datadog
-  module OpenTracer
-    # OpenTracing propagator for Datadog::OpenTracer::Tracer
-    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/ddtrace/opentracer/rack_propagator.rb

@@ -1,61 +0,0 @@
-# typed: true
-require 'ddtrace/propagation/http_propagator'
-
-module Datadog
-  module OpenTracer
-    # OpenTracing propagator for Datadog::OpenTracer::Tracer
-    module RackPropagator
-      extend Propagator
-      extend Datadog::Ext::DistributedTracing
-      include Datadog::Ext::DistributedTracing
-
-      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)
-          # Inject Datadog trace properties
-          Datadog::HTTPPropagator.inject!(span_context.datadog_context, 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_context = Datadog::HTTPPropagator.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: datadog_context, 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/ddtrace/opentracer/scope.rb

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

data/lib/ddtrace/opentracer/scope_manager.rb

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