ddtrace 0.38.0

data/lib/ddtrace/ext/analytics.rb

@@ -0,0 +1,12 @@
+module Datadog
+  module Ext
+    # Defines constants for trace analytics
+    module Analytics
+      DEFAULT_SAMPLE_RATE = 1.0
+      ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
+      TAG_ENABLED = 'analytics.enabled'.freeze
+      TAG_MEASURED = '_dd.measured'.freeze
+      TAG_SAMPLE_RATE = '_dd1.sr.eausr'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/app_types.rb

@@ -0,0 +1,11 @@
+module Datadog
+  module Ext
+    module AppTypes
+      WEB = 'web'.freeze
+      DB = 'db'.freeze
+      CACHE = 'cache'.freeze
+      WORKER = 'worker'.freeze
+      CUSTOM = 'custom'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/correlation.rb

@@ -0,0 +1,11 @@
+module Datadog
+  module Ext
+    module Correlation
+      ATTR_ENV = 'dd.env'.freeze
+      ATTR_SERVICE = 'dd.service'.freeze
+      ATTR_SPAN_ID = 'dd.span_id'.freeze
+      ATTR_TRACE_ID = 'dd.trace_id'.freeze
+      ATTR_VERSION = 'dd.version'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/diagnostics.rb

@@ -0,0 +1,35 @@
+module Datadog
+  module Ext
+    module Diagnostics
+      DD_TRACE_STARTUP_LOGS = 'DD_TRACE_STARTUP_LOGS'.freeze
+
+      # Health
+      module Health
+        # Metrics
+        module Metrics
+          ENV_ENABLED = 'DD_HEALTH_METRICS_ENABLED'.freeze
+
+          METRIC_API_ERRORS = 'datadog.tracer.api.errors'.freeze
+          METRIC_API_REQUESTS = 'datadog.tracer.api.requests'.freeze
+          METRIC_API_RESPONSES = 'datadog.tracer.api.responses'.freeze
+          METRIC_ERROR_CONTEXT_OVERFLOW = 'datadog.tracer.error.context_overflow'.freeze
+          METRIC_ERROR_INSTRUMENTATION_PATCH = 'datadog.tracer.error.instrumentation_patch'.freeze
+          METRIC_ERROR_SPAN_FINISH = 'datadog.tracer.error.span_finish'.freeze
+          METRIC_ERROR_UNFINISHED_SPANS = 'datadog.tracer.error.unfinished_spans'.freeze
+          METRIC_INSTRUMENTATION_PATCHED = 'datadog.tracer.instrumentation_patched'.freeze
+          METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'.freeze
+          METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'.freeze
+          METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'.freeze
+          METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'.freeze
+          METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'.freeze
+          METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'.freeze
+          METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'.freeze
+          METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
+          METRIC_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'.freeze
+          METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'.freeze
+          METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/distributed.rb

@@ -0,0 +1,33 @@
+module Datadog
+  module Ext
+    module DistributedTracing
+      # HTTP headers one should set for distributed tracing.
+      # These are cross-language (eg: Python, Go and other implementations should honor these)
+      HTTP_HEADER_TRACE_ID = 'x-datadog-trace-id'.freeze
+      HTTP_HEADER_PARENT_ID = 'x-datadog-parent-id'.freeze
+      HTTP_HEADER_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
+      SAMPLING_PRIORITY_KEY = '_sampling_priority_v1'.freeze
+      HTTP_HEADER_ORIGIN = 'x-datadog-origin'.freeze
+      ORIGIN_KEY = '_dd.origin'.freeze
+
+      # B3 headers used for distributed tracing
+      B3_HEADER_TRACE_ID = 'x-b3-traceid'.freeze
+      B3_HEADER_SPAN_ID = 'x-b3-spanid'.freeze
+      B3_HEADER_SAMPLED = 'x-b3-sampled'.freeze
+      B3_HEADER_SINGLE = 'b3'.freeze
+
+      # Distributed tracing propagation options
+      PROPAGATION_STYLE_DATADOG = 'Datadog'.freeze
+      PROPAGATION_STYLE_B3 = 'B3'.freeze
+      PROPAGATION_STYLE_B3_SINGLE_HEADER = 'B3 single header'.freeze
+      PROPAGATION_INJECT_STYLE_ENV = 'DD_PROPAGATION_INJECT_STYLE'.freeze
+      PROPAGATION_EXTRACT_STYLE_ENV = 'DD_PROPAGATION_EXTRACT_STYLE'.freeze
+
+      # gRPC metadata keys for distributed tracing. https://github.com/grpc/grpc-go/blob/v1.10.x/Documentation/grpc-metadata.md
+      GRPC_METADATA_TRACE_ID = 'x-datadog-trace-id'.freeze
+      GRPC_METADATA_PARENT_ID = 'x-datadog-parent-id'.freeze
+      GRPC_METADATA_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
+      GRPC_METADATA_ORIGIN = 'x-datadog-origin'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/environment.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Ext
+    module Environment
+      ENV_API_KEY = 'DD_API_KEY'.freeze
+      ENV_ENVIRONMENT = 'DD_ENV'.freeze
+      ENV_SERVICE = 'DD_SERVICE'.freeze
+      ENV_SITE = 'DD_SITE'.freeze
+      ENV_TAGS = 'DD_TAGS'.freeze
+      ENV_VERSION = 'DD_VERSION'.freeze
+
+      TAG_ENV = 'env'.freeze
+      TAG_SERVICE = 'service'.freeze
+      TAG_VERSION = 'version'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/errors.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module Ext
+    module Errors
+      STATUS = 1
+      MSG = 'error.msg'.freeze
+      TYPE = 'error.type'.freeze
+      STACK = 'error.stack'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/forced_tracing.rb

@@ -0,0 +1,25 @@
+require 'ddtrace/ext/manual_tracing'
+require 'ddtrace/tracer'
+
+module Datadog
+  module Ext
+    # Defines constants for forced tracing
+    module ForcedTracing
+      @deprecation_warning_shown = false
+
+      def self.const_missing(name)
+        super unless Ext::ManualTracing.const_defined?(name)
+
+        # Only log each deprecation warning once (safeguard against log spam)
+        unless @deprecation_warning_shown
+          Datadog.logger.warn(
+            'forced tracing: Datadog::Ext::ForcedTracing has been renamed to Datadog::Ext::ManualTracing'
+          )
+          @deprecation_warning_shown = true
+        end
+
+        Ext::ManualTracing.const_get(name)
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/http.rb

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,16 @@
+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

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

data/lib/ddtrace/ext/transport.rb

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,40 @@
+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::WARN
+    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

@@ -0,0 +1,222 @@
+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.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.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.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.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.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