ddtrace 0.34.1 → 1.23.1

data/lib/datadog/core/error.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+module Datadog
+  module Core
+    # Error is a value-object responsible for sanitizing/encapsulating error data
+    class Error
+      attr_reader :type, :message, :backtrace
+
+      class << self
+        def build_from(value)
+          case value
+          when Error then value
+          when Array then new(*value)
+          when Exception then new(value.class, value.message, full_backtrace(value))
+          when ContainsMessage then new(value.class, value.message)
+          when String then new(nil, value)
+          else BlankError
+          end
+        end
+
+        private
+
+        # Returns a stack trace with nested error causes and details.
+        #
+        # This manually implements Ruby >= 2.6 error output for two reasons:
+        #
+        # 1. It is not available in Ruby < 2.6.
+        # 2. It's measurably faster to manually implement it in Ruby.
+        #
+        # This method mimics the exact output of
+        # `ex.full_message(highlight: false, order: :top)`
+        # but it's around 3x faster in our benchmark test
+        # at `error_spec.rb`.
+        def full_backtrace(ex)
+          backtrace = String.new
+          backtrace_for(ex, backtrace)
+
+          # Avoid circular causes
+          causes = {}
+          causes[ex] = true
+
+          cause = ex
+          while (cause = cause.cause) && !causes.key?(cause)
+            backtrace_for(cause, backtrace)
+            causes[cause] = true
+          end
+
+          backtrace
+        end
+
+        # Outputs the following format for exceptions:
+        #
+        # ```
+        # error_spec.rb:55:in `wrapper': wrapper layer (RuntimeError)
+        # 	from error_spec.rb:40:in `wrapper'
+        # 	from error_spec.rb:61:in `caller'
+        #   ...
+        # ```
+        def backtrace_for(ex, backtrace)
+          trace = ex.backtrace
+          return unless trace
+
+          if trace[0]
+            # Add Exception information to error line
+            backtrace << trace[0]
+            backtrace << ': '
+            backtrace << ex.message.to_s
+            backtrace << ' ('
+            backtrace << ex.class.to_s
+            backtrace << ')'
+          end
+
+          if trace[1]
+            # Ident stack trace for caller lines, to separate
+            # them from the main error lines.
+            trace[1..-1].each do |line|
+              backtrace << "\n\tfrom "
+              backtrace << line
+            end
+          end
+
+          backtrace << "\n"
+        end
+      end
+
+      def initialize(type = nil, message = nil, backtrace = nil)
+        backtrace = Array(backtrace).join("\n") unless backtrace.is_a?(String)
+
+        @type = Utils.utf8_encode(type)
+        @message = Utils.utf8_encode(message)
+        @backtrace = Utils.utf8_encode(backtrace)
+      end
+
+      BlankError = Error.new
+      ContainsMessage = ->(v) { v.respond_to?(:message) }
+    end
+  end
+end

data/lib/datadog/core/extensions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'configuration'
+
+# Global namespace that includes all Datadog functionality.
+# @public_api
+module Datadog
+  module Core
+    # Used to decorate Datadog module with additional behavior
+    module Extensions
+      def self.extended(base)
+        base.extend(Core::Configuration)
+      end
+    end
+  end
+end

data/lib/datadog/core/git/ext.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Git
+      # Defines constants for Git tags
+      module Ext
+        TAG_REPOSITORY_URL = '_dd.git.repository_url'
+        TAG_COMMIT_SHA = '_dd.git.commit.sha'
+
+        ENV_REPOSITORY_URL = 'DD_GIT_REPOSITORY_URL'
+        ENV_COMMIT_SHA = 'DD_GIT_COMMIT_SHA'
+      end
+    end
+  end
+end

data/lib/datadog/core/header_collection.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    # A some-what abstract class representing a collection of headers.
+    #
+    # Use the `HeaderCollection.from_hash` function to create a header collection from a `Hash`.
+    # Another option is to use `HashHeaderCollection` directly.
+    class HeaderCollection
+      # Gets a single value of the header with the given name, case insensitive.
+      #
+      # @param [String] header_name Name of the header to get the value of.
+      # @returns [String, nil] A single value of the header, or nil if the header with
+      #   the given name is missing from the collection.
+      def get(header_name)
+        nil
+      end
+
+      # Create a header collection that retrieves headers from the given Hash.
+      #
+      # This can be useful for testing or other trivial use cases.
+      #
+      # @param [Hash] hash Hash with the headers.
+      def self.from_hash(hash)
+        HashHeaderCollection.new(hash)
+      end
+    end
+
+    # A header collection implementation that looks up headers in a Hash.
+    class HashHeaderCollection < HeaderCollection
+      def initialize(hash)
+        super()
+        @hash = {}.tap do |res|
+          hash.each_pair { |key, value| res[key.downcase] = value }
+        end
+      end
+
+      def get(header_name)
+        @hash[header_name.downcase]
+      end
+    end
+  end
+end

data/lib/datadog/core/logger.rb

@@ -0,0 +1,44 @@
+require 'logger'
+
+module Datadog
+  module Core
+    # 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
+    # @public_api
+    class Logger < ::Logger
+      # TODO: Consider renaming this to 'datadog'
+      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
+end

data/lib/datadog/core/logging/ext.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Logging
+      module Ext
+        # The technology from which the log originated.
+        # @see https://docs.datadoghq.com/api/latest/logs/#send-logs
+        DD_SOURCE = 'ruby'
+      end
+    end
+  end
+end

data/lib/datadog/core/metrics/client.rb

@@ -0,0 +1,197 @@
+require_relative '../utils/time'
+require_relative '../utils/only_once'
+require_relative '../configuration/ext'
+
+require_relative 'ext'
+require_relative 'options'
+require_relative 'helpers'
+require_relative 'logging'
+require_relative 'metric'
+
+module Datadog
+  module Core
+    module Metrics
+      # Acts as client for sending metrics (via Statsd)
+      # Wraps a Statsd client with default tags and additional configuration.
+      class Client
+        include Options
+        extend Options
+        extend Helpers
+
+        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(Configuration::Ext::Transport::ENV_DEFAULT_HOST, Ext::DEFAULT_HOST)
+        end
+
+        def default_port
+          ENV.fetch(Configuration::Ext::Metrics::ENV_DEFAULT_PORT, Ext::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.class.name} #{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.class.name} #{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.class.name} #{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.class.name} #{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.class.name} #{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
+
+        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 = 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
+  end
+end

data/lib/datadog/core/metrics/ext.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Metrics
+      # @public_api
+      module Ext
+        DEFAULT_HOST = '127.0.0.1'
+        DEFAULT_PORT = 8125
+
+        TAG_LANG = 'language'
+        TAG_LANG_INTERPRETER = 'language-interpreter'
+        TAG_LANG_VERSION = 'language-version'
+        TAG_TRACER_VERSION = 'tracer-version'
+      end
+    end
+  end
+end

data/lib/datadog/core/metrics/helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Metrics
+      # 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
+    end
+  end
+end

data/lib/datadog/core/metrics/logging.rb

@@ -0,0 +1,42 @@
+require 'logger'
+require 'json'
+
+module Datadog
+  module Core
+    module Metrics
+      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
+    end
+  end
+end

data/lib/datadog/core/metrics/metric.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Metrics
+      Metric = Struct.new(:type, :name, :value, :options) do
+        def initialize(*args)
+          super
+          self.options = options || {}
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/metrics/options.rb

@@ -0,0 +1,48 @@
+require_relative 'ext'
+require_relative '../environment/ext'
+require_relative '../environment/identity'
+
+module Datadog
+  module Core
+    module Metrics
+      # For defining and adding default options to metrics
+      module Options
+        DEFAULT = {
+          tags: DEFAULT_TAGS = [
+            "#{Ext::TAG_LANG}:#{Environment::Identity.lang}".freeze,
+            "#{Ext::TAG_LANG_INTERPRETER}:#{Environment::Identity.lang_interpreter}".freeze,
+            "#{Ext::TAG_LANG_VERSION}:#{Environment::Identity.lang_version}".freeze,
+            "#{Ext::TAG_TRACER_VERSION}:#{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] << "#{Environment::Ext::TAG_ENV}:#{env}" unless env.nil?
+
+            version = Datadog.configuration.version
+            options[:tags] << "#{Environment::Ext::TAG_VERSION}:#{version}" unless version.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/pin.rb

@@ -0,0 +1,73 @@
+module Datadog
+  module Core
+    # A {Datadog::Core::Pin} sets metadata on a particular object.
+    #
+    # This is useful if you want the object to reflect
+    # customized behavior or attributes, like an eigenclass.
+    class Pin
+      def self.get_from(obj)
+        return nil unless obj.respond_to? :datadog_pin
+
+        obj.datadog_pin
+      end
+
+      def self.set_on(obj, **options)
+        if (pin = get_from(obj))
+          options.each { |k, v| pin[k] = v }
+        else
+          pin = new(**options)
+          pin.onto(obj)
+        end
+
+        pin
+      end
+
+      def initialize(**options)
+        @options = options
+      end
+
+      def [](name)
+        @options[name]
+      end
+
+      def []=(name, value)
+        @options[name] = value
+      end
+
+      def key?(name)
+        @options.key?(name)
+      end
+
+      # rubocop:disable Style/TrivialAccessors
+      def onto(obj)
+        unless obj.respond_to? :datadog_pin=
+          obj.instance_exec do
+            def datadog_pin=(pin)
+              @datadog_pin = pin
+            end
+          end
+        end
+
+        unless obj.respond_to? :datadog_pin
+          obj.instance_exec do
+            def datadog_pin
+              @datadog_pin
+            end
+          end
+        end
+
+        obj.datadog_pin = self
+      end
+      # rubocop:enable Style/TrivialAccessors
+
+      def to_s
+        pretty_options = options.to_a.map { |k, v| "#{k}:#{v}" }.join(', ')
+        "Pin(#{pretty_options})"
+      end
+
+      private
+
+      attr_accessor :options
+    end
+  end
+end