ddtrace 0.53.0 → 1.0.0.beta1

data/lib/datadog/core/encoding.rb

@@ -0,0 +1,75 @@
+# typed: true
+require 'json'
+require 'msgpack'
+
+module Datadog
+  module Core
+    # Encoding module that encodes data for the AgentTransport
+    module Encoding
+      # Encoder interface that provides the logic to encode traces and service
+      # @abstract
+      module Encoder
+        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+        def content_type
+          raise NotImplementedError
+        end
+
+        # Concatenates a list of elements previously encoded by +#encode+.
+        def join(encoded_elements)
+          raise NotImplementedError
+        end
+
+        # Serializes a single trace into a String suitable for network transmission.
+        def encode(_)
+          raise NotImplementedError
+        end
+      end
+
+      # Encoder for the JSON format
+      module JSONEncoder
+        extend Encoder
+
+        CONTENT_TYPE = 'application/json'.freeze
+
+        module_function
+
+        def content_type
+          CONTENT_TYPE
+        end
+
+        def encode(obj)
+          JSON.dump(obj)
+        end
+
+        def join(encoded_data)
+          "[#{encoded_data.join(',')}]"
+        end
+      end
+
+      # Encoder for the Msgpack format
+      module MsgpackEncoder
+        extend Encoder
+
+        module_function
+
+        CONTENT_TYPE = 'application/msgpack'.freeze
+
+        def content_type
+          CONTENT_TYPE
+        end
+
+        def encode(obj)
+          MessagePack.pack(obj)
+        end
+
+        def join(encoded_data)
+          packer = MessagePack::Packer.new
+          packer.write_array_header(encoded_data.size)
+
+          (packer.buffer.to_a + encoded_data).join
+        end
+      end
+    end
+  end
+end

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

@@ -4,16 +4,8 @@ require 'ddtrace/version'
 module Datadog
   module Core
     module Environment
+      # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
       module Ext
-        # Identity
-        LANG = 'ruby'.freeze
-        LANG_ENGINE = RUBY_ENGINE
-        LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}".freeze
-        LANG_PLATFORM = RUBY_PLATFORM
-        LANG_VERSION = RUBY_VERSION
-        RUBY_ENGINE = ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
-        TRACER_VERSION = Datadog::VERSION::STRING
-
         # e.g for CRuby '3.0.1', for JRuby '9.2.19.0', for TruffleRuby '21.1.0'
         ENGINE_VERSION = if defined?(RUBY_ENGINE_VERSION)
                            RUBY_ENGINE_VERSION
@@ -21,6 +13,32 @@ module Datadog
                            # CRuby < 2.3 doesn't support RUBY_ENGINE_VERSION
                            RUBY_VERSION
                          end
+
+        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
+        FALLBACK_SERVICE_NAME =
+          begin
+            File.basename($PROGRAM_NAME, '.*')
+          rescue StandardError
+            'ruby'
+          end.freeze
+
+        LANG = 'ruby'.freeze
+        LANG_ENGINE = RUBY_ENGINE
+        LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}".freeze
+        LANG_PLATFORM = RUBY_PLATFORM
+        LANG_VERSION = RUBY_VERSION
+        RUBY_ENGINE = ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
+        TAG_ENV = 'env'.freeze
+        TAG_SERVICE = 'service'.freeze
+        TAG_VERSION = 'version'.freeze
+
+        # TODO: Migrate to Datadog::Tracing
+        TRACER_VERSION = DDTrace::VERSION::STRING
       end
     end
   end

data/lib/datadog/core/environment/identity.rb

@@ -1,27 +1,33 @@
 # typed: false
 require 'securerandom'
+
 require 'datadog/core/environment/ext'
-require 'ddtrace/utils/forking'
+require 'datadog/core/utils/forking'
 
 module Datadog
   module Core
     module Environment
       # For runtime identity
+      # @public_api
       module Identity
-        extend Datadog::Utils::Forking
+        extend Core::Utils::Forking
 
         module_function
 
         # Retrieves number of classes from runtime
         def id
-          @id ||= SecureRandom.uuid
+          @id ||= ::SecureRandom.uuid.freeze
 
           # Check if runtime has changed, e.g. forked.
-          after_fork! { @id = SecureRandom.uuid }
+          after_fork! { @id = ::SecureRandom.uuid.freeze }
 
           @id
         end
 
+        def pid
+          ::Process.pid
+        end
+
         def lang
           Core::Environment::Ext::LANG
         end

data/lib/datadog/core/environment/socket.rb

@@ -1,15 +1,21 @@
-# typed: true
+# typed: false
 require 'socket'
+require 'datadog/core/utils/forking'
 
 module Datadog
   module Core
     module Environment
       # For runtime identity
       module Socket
+        extend Core::Utils::Forking
+
         module_function
 
         def hostname
-          ::Socket.gethostname
+          # Check if runtime has changed, e.g. forked.
+          after_fork! { @hostname = ::Socket.gethostname.freeze }
+
+          @hostname ||= ::Socket.gethostname.freeze
         end
       end
     end

data/lib/datadog/core/environment/variable_helpers.rb

@@ -4,6 +4,7 @@ module Datadog
     # Namespace for handling application environment
     module Environment
       # Defines helper methods for environment
+      # @public_api
       module VariableHelpers
         extend self
 

data/lib/datadog/core/error.rb

@@ -0,0 +1,100 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'datadog/core/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)
+          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,15 @@
+# typed: strict
+require 'datadog/core/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,34 @@
+# typed: true
+module Datadog
+  module Core
+    module Git
+      # Defines constants for Git tags
+      module Ext
+        TAG_BRANCH = 'git.branch'.freeze
+        TAG_REPOSITORY_URL = 'git.repository_url'.freeze
+        TAG_TAG = 'git.tag'.freeze
+
+        TAG_COMMIT_AUTHOR_DATE = 'git.commit.author.date'.freeze
+        TAG_COMMIT_AUTHOR_EMAIL = 'git.commit.author.email'.freeze
+        TAG_COMMIT_AUTHOR_NAME = 'git.commit.author.name'.freeze
+        TAG_COMMIT_COMMITTER_DATE = 'git.commit.committer.date'.freeze
+        TAG_COMMIT_COMMITTER_EMAIL = 'git.commit.committer.email'.freeze
+        TAG_COMMIT_COMMITTER_NAME = 'git.commit.committer.name'.freeze
+        TAG_COMMIT_MESSAGE = 'git.commit.message'.freeze
+        TAG_COMMIT_SHA = 'git.commit.sha'.freeze
+
+        ENV_REPOSITORY_URL = 'DD_GIT_REPOSITORY_URL'.freeze
+        ENV_COMMIT_SHA = 'DD_GIT_COMMIT_SHA'.freeze
+        ENV_BRANCH = 'DD_GIT_BRANCH'.freeze
+        ENV_TAG = 'DD_GIT_TAG'.freeze
+        ENV_COMMIT_MESSAGE = 'DD_GIT_COMMIT_MESSAGE'.freeze
+        ENV_COMMIT_AUTHOR_NAME = 'DD_GIT_COMMIT_AUTHOR_NAME'.freeze
+        ENV_COMMIT_AUTHOR_EMAIL = 'DD_GIT_COMMIT_AUTHOR_EMAIL'.freeze
+        ENV_COMMIT_AUTHOR_DATE = 'DD_GIT_COMMIT_AUTHOR_DATE'.freeze
+        ENV_COMMIT_COMMITTER_NAME = 'DD_GIT_COMMIT_COMMITTER_NAME'.freeze
+        ENV_COMMIT_COMMITTER_EMAIL = 'DD_GIT_COMMIT_COMMITTER_EMAIL'.freeze
+        ENV_COMMIT_COMMITTER_DATE = 'DD_GIT_COMMIT_COMMITTER_DATE'.freeze
+      end
+    end
+  end
+end

data/lib/datadog/core/logger.rb

@@ -0,0 +1,45 @@
+# typed: true
+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/metrics/client.rb

@@ -0,0 +1,187 @@
+# typed: false
+require 'datadog/core/utils/time'
+require 'datadog/core/utils/only_once'
+
+require 'datadog/core/metrics/ext'
+require 'datadog/core/metrics/options'
+require 'datadog/core/metrics/helpers'
+require 'datadog/core/metrics/logging'
+require 'datadog/core/metrics/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(Ext::ENV_DEFAULT_HOST, Ext::DEFAULT_HOST)
+        end
+
+        def default_port
+          ENV.fetch(Ext::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.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
+
+        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,19 @@
+# typed: true
+module Datadog
+  module Core
+    module Metrics
+      # @public_api
+      module Ext
+        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
+end

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

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