ddtrace 0.34.1 → 1.23.1

data/lib/ddtrace/ext/http.rb

@@ -1,46 +0,0 @@
-module Datadog
-  module Ext
-    module HTTP
-      BASE_URL = 'http.base_url'.freeze
-      ERROR_RANGE = 500...600
-      METHOD = 'http.method'.freeze
-      STATUS_CODE = 'http.status_code'.freeze
-      TEMPLATE = 'template'.freeze
-      TYPE_INBOUND = 'web'.freeze
-      TYPE_OUTBOUND = 'http'.freeze
-      TYPE_PROXY = 'proxy'.freeze
-      URL = 'http.url'.freeze
-
-      # General header functionality
-      module Headers
-        module_function
-
-        def to_tag(name)
-          name.to_s.downcase.gsub(/[-\s]/, '_')
-        end
-      end
-
-      # Request headers
-      module RequestHeaders
-        PREFIX = 'http.request.headers'.freeze
-
-        module_function
-
-        def to_tag(name)
-          "#{PREFIX}.#{Headers.to_tag(name)}"
-        end
-      end
-
-      # Response headers
-      module ResponseHeaders
-        PREFIX = 'http.response.headers'.freeze
-
-        module_function
-
-        def to_tag(name)
-          "#{PREFIX}.#{Headers.to_tag(name)}"
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/ext/manual_tracing.rb

@@ -1,9 +0,0 @@
-module Datadog
-  module Ext
-    # Defines constants for manual tracing
-    module ManualTracing
-      TAG_KEEP = 'manual.keep'.freeze
-      TAG_DROP = 'manual.drop'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/metrics.rb

@@ -1,15 +0,0 @@
-module Datadog
-  module Ext
-    module Metrics
-      DEFAULT_HOST = '127.0.0.1'.freeze
-      DEFAULT_PORT = 8125
-      ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
-      ENV_DEFAULT_PORT = 'DD_METRIC_AGENT_PORT'.freeze
-
-      TAG_LANG = 'language'.freeze
-      TAG_LANG_INTERPRETER = 'language-interpreter'.freeze
-      TAG_LANG_VERSION = 'language-version'.freeze
-      TAG_TRACER_VERSION = 'tracer-version'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/net.rb

@@ -1,10 +0,0 @@
-module Datadog
-  module Ext
-    module NET
-      ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'.freeze
-      TAG_HOSTNAME = '_dd.hostname'.freeze
-      TARGET_HOST = 'out.host'.freeze
-      TARGET_PORT = 'out.port'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/priority.rb

@@ -1,16 +0,0 @@
-module Datadog
-  module Ext
-    # Priority is a hint given to the backend so that it knows which traces to reject or kept.
-    # In a distributed context, it should be set before any context propagation (fork, RPC calls) to be effective.
-    module Priority
-      # Use this to explicitely inform the backend that a trace should be rejected and not stored.
-      USER_REJECT = -1
-      # Used by the builtin sampler to inform the backend that a trace should be rejected and not stored.
-      AUTO_REJECT = 0
-      # Used by the builtin sampler to inform the backend that a trace should be kept and stored.
-      AUTO_KEEP = 1
-      # Use this to explicitely inform the backend that a trace should be kept and stored.
-      USER_KEEP = 2
-    end
-  end
-end

data/lib/ddtrace/ext/runtime.rb

@@ -1,26 +0,0 @@
-require 'ddtrace/version'
-
-module Datadog
-  module Ext
-    module Runtime
-      # Identity
-      LANG = 'ruby'.freeze
-      LANG_INTERPRETER = (RUBY_ENGINE + '-' + RUBY_PLATFORM).freeze
-      LANG_VERSION = RUBY_VERSION
-      TRACER_VERSION = Datadog::VERSION::STRING
-
-      TAG_LANG = 'language'.freeze
-
-      # Metrics
-      module Metrics
-        ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'.freeze
-
-        METRIC_CLASS_COUNT = 'runtime.ruby.class_count'.freeze
-        METRIC_GC_PREFIX = 'runtime.ruby.gc'.freeze
-        METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'.freeze
-
-        TAG_SERVICE = 'service'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/ext/sampling.rb

@@ -1,16 +0,0 @@
-module Datadog
-  module Ext
-    module Sampling
-      ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'.freeze
-      ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'.freeze
-
-      # If rule sampling is applied to a span, set this metric the sample rate configured for that rule.
-      # This should be done regardless of sampling outcome.
-      RULE_SAMPLE_RATE = '_dd.rule_psr'.freeze
-
-      # If rate limiting is checked on a span, set this metric the effective rate limiting rate applied.
-      # This should be done regardless of rate limiting outcome.
-      RATE_LIMITER_RATE = '_dd.limit_psr'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/sql.rb

@@ -1,8 +0,0 @@
-module Datadog
-  module Ext
-    module SQL
-      TYPE = 'sql'.freeze
-      QUERY = 'sql.query'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/transport.rb

@@ -1,17 +0,0 @@
-module Datadog
-  module Ext
-    module Transport
-      module HTTP
-        DEFAULT_HOST = '127.0.0.1'.freeze
-        DEFAULT_PORT = 8126
-        ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
-        ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'.freeze
-        HEADER_CONTAINER_ID = 'Datadog-Container-ID'.freeze
-        HEADER_META_LANG = 'Datadog-Meta-Lang'.freeze
-        HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'.freeze
-        HEADER_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'.freeze
-        HEADER_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/forced_tracing.rb

@@ -1,36 +0,0 @@
-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,81 +0,0 @@
-require 'logger'
-
-module Datadog
-  LOG_PREFIX = 'ddtrace'.freeze
-
-  # 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
-    # Global, memoized, lazy initialized instance of a logger that is used within the the Datadog
-    # namespace. This logger outputs to +STDOUT+ by default, and is considered thread-safe.
-    class << self
-      def log
-        unless defined? @logger
-          @logger = Datadog::Logger.new(STDOUT)
-          @logger.level = Logger::WARN
-        end
-        @logger
-      end
-
-      # Override the default logger with a custom one.
-      def log=(logger)
-        return unless logger
-        return unless logger.respond_to? :methods
-        return unless logger.respond_to? :error
-        if logger.respond_to? :methods
-          unimplemented = new(STDOUT).methods - logger.methods
-          unless unimplemented.empty?
-            logger.error("logger #{logger} does not implement #{unimplemented}")
-            return
-          end
-        end
-        @logger = logger
-      end
-
-      # Activate the debug mode providing more information related to tracer usage
-      # Default to Warn level unless using custom logger
-      def debug_logging=(value)
-        if value
-          log.level = Logger::DEBUG
-        elsif log.is_a?(Datadog::Logger)
-          log.level = Logger::WARN
-        end
-      end
-
-      # Return if the debug mode is activated or not
-      def debug_logging
-        log.level == Logger::DEBUG
-      end
-    end
-
-    def initialize(*args, &block)
-      super
-      self.progname = LOG_PREFIX
-    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_given?
-          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,222 +0,0 @@
-require 'ddtrace/ext/metrics'
-
-require 'set'
-require 'logger'
-require 'ddtrace/environment'
-require 'ddtrace/utils/time'
-require 'ddtrace/runtime/identity'
-
-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(options = {})
-      @statsd = options.fetch(:statsd) { default_statsd_client if supported? }
-      @enabled = options.fetch(:enabled, true)
-    end
-
-    def supported?
-      version = Gem.loaded_specs['dogstatsd-ruby'] \
-                  && Gem.loaded_specs['dogstatsd-ruby'].version
-
-      !version.nil? && (version >= Gem::Version.new('3.3.0'))
-    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' unless defined?(::Datadog::Statsd)
-
-      # Create a StatsD client that points to the agent.
-      Datadog::Statsd.new(default_hostname, default_port)
-    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_given?
-      raise ArgumentError if value.nil?
-
-      statsd.count(stat, value, metric_options(options))
-    rescue StandardError => e
-      Datadog::Logger.log.error("Failed to send count stat. Cause: #{e.message} Source: #{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_given?
-      raise ArgumentError if value.nil?
-
-      statsd.distribution(stat, value, metric_options(options))
-    rescue StandardError => e
-      Datadog::Logger.log.error("Failed to send distribution stat. Cause: #{e.message} Source: #{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.log.error("Failed to send increment stat. Cause: #{e.message} Source: #{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_given?
-      raise ArgumentError if value.nil?
-
-      statsd.gauge(stat, value, metric_options(options))
-    rescue StandardError => e
-      Datadog::Logger.log.error("Failed to send gauge stat. Cause: #{e.message} Source: #{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
-      return 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.log.error("Failed to send time stat. Cause: #{e.message} Source: #{e.backtrace.first}")
-      end
-    end
-
-    def send_metrics(metrics)
-      metrics.each { |m| send(m.type, *[m.name, m.value, m.options].compact) }
-    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}:#{Runtime::Identity.lang}".freeze,
-          "#{Ext::Metrics::TAG_LANG_INTERPRETER}:#{Runtime::Identity.lang_interpreter}".freeze,
-          "#{Ext::Metrics::TAG_LANG_VERSION}:#{Runtime::Identity.lang_version}".freeze,
-          "#{Ext::Metrics::TAG_TRACER_VERSION}:#{Runtime::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
-  end
-end

data/lib/ddtrace/monkey.rb

@@ -1,58 +0,0 @@
-module Datadog
-  # TODO: Remove me!
-  # Monkey was used for monkey-patching 3rd party libs.
-  # It is now DEPRECATED. This API is no-op, and serves only to warn
-  # of its deactivation.
-  module Monkey
-    @registry = Datadog.registry
-
-    DEPRECATION_WARNING = %(
-      Datadog::Monkey has been REMOVED as of version 0.11.1.
-      All calls to Datadog::Monkey are no-ops.
-      *Implementations using Monkey will no longer function*.
-      Upgrade to the new configuration API using the migration guide here:
-      https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
-
-    module_function
-
-    def registry
-      log_deprecation_warning('Monkey#registry')
-      @registry
-    end
-
-    def autopatch_modules
-      log_deprecation_warning('Monkey#autopatch_modules')
-      {}
-    end
-
-    def patch_all
-      log_deprecation_warning('Monkey#patch_all')
-    end
-
-    def patch_module(m)
-      log_deprecation_warning('Monkey#patch_module')
-    end
-
-    def patch(modules)
-      log_deprecation_warning('Monkey#patch')
-    end
-
-    def get_patched_modules
-      log_deprecation_warning('Monkey#get_patched_modules')
-      {}
-    end
-
-    def without_warnings(&block)
-      log_deprecation_warning('Monkey#without_warnings')
-      Datadog::Patcher.without_warnings(&block)
-    end
-
-    def log_deprecation_warning(method)
-      Datadog::Logger.log.warn("#{method}:#{DEPRECATION_WARNING}")
-    end
-
-    class << self
-      attr_writer :registry
-    end
-  end
-end

data/lib/ddtrace/opentelemetry/extensions.rb

@@ -1,13 +0,0 @@
-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.send(:prepend, OpenTelemetry::Span)
-      end
-    end
-  end
-end

data/lib/ddtrace/opentelemetry/span.rb

@@ -1,33 +0,0 @@
-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,24 +0,0 @@
-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,6 +0,0 @@
-module Datadog
-  module OpenTracer
-    class Carrier < ::OpenTracing::Carrier
-    end
-  end
-end