ddtrace 0.50.0 → 1.0.0

data/lib/datadog/core/logger.rb

@@ -0,0 +1,46 @@
+# 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,188 @@
+# 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,20 @@
+# 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,25 @@
+# typed: false
+
+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,44 @@
+# typed: true
+
+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 @@
+# typed: false
+
+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,50 @@
+# typed: true
+
+require 'datadog/core/metrics/ext'
+require 'datadog/core/environment/ext'
+require 'datadog/core/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,75 @@
+# typed: true
+
+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

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

@@ -0,0 +1,28 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Runtime
+      # @public_api
+      module Ext
+        TAG_ID = 'runtime-id'.freeze
+        TAG_LANG = 'language'.freeze
+        TAG_PID = 'system.pid'.freeze
+
+        # Metrics
+        # @public_api
+        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
+          METRIC_GLOBAL_CONSTANT_STATE = 'runtime.ruby.global_constant_state'.freeze
+          METRIC_GLOBAL_METHOD_STATE = 'runtime.ruby.global_method_state'.freeze
+
+          TAG_SERVICE = 'service'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# typed: true
+
+require 'datadog/core/runtime/ext'
+
+require 'datadog/core/metrics/client'
+require 'datadog/core/environment/class_count'
+require 'datadog/core/environment/gc'
+require 'datadog/core/environment/thread_count'
+require 'datadog/core/environment/vm_cache'
+
+module Datadog
+  module Core
+    module Runtime
+      # For generating runtime metrics
+      class Metrics < Core::Metrics::Client
+        def initialize(**options)
+          super
+
+          # Initialize service list
+          @services = Set.new(options.fetch(:services, []))
+          @service_tags = nil
+          compile_service_tags!
+        end
+
+        # Associate service with runtime metrics
+        def register_service(service)
+          return unless enabled? && service
+
+          service = service.to_s
+
+          unless @services.include?(service)
+            # Add service to list and update services tag
+            services << service
+
+            # Recompile the service tags
+            compile_service_tags!
+          end
+        end
+
+        # Flush all runtime metrics to Statsd client
+        def flush
+          return unless enabled?
+
+          try_flush do
+            if Core::Environment::ClassCount.available?
+              gauge(Core::Runtime::Ext::Metrics::METRIC_CLASS_COUNT, Core::Environment::ClassCount.value)
+            end
+          end
+
+          try_flush do
+            if Core::Environment::ThreadCount.available?
+              gauge(Core::Runtime::Ext::Metrics::METRIC_THREAD_COUNT, Core::Environment::ThreadCount.value)
+            end
+          end
+
+          try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if Core::Environment::GC.available? }
+
+          try_flush do
+            if Core::Environment::VMCache.available?
+              gauge(
+                Core::Runtime::Ext::Metrics::METRIC_GLOBAL_CONSTANT_STATE,
+                Core::Environment::VMCache.global_constant_state
+              )
+
+              # global_method_state is not available since Ruby >= 3.0,
+              # as method caching was moved to a per-class basis.
+              global_method_state = Core::Environment::VMCache.global_method_state
+              gauge(Core::Runtime::Ext::Metrics::METRIC_GLOBAL_METHOD_STATE, global_method_state) if global_method_state
+            end
+          end
+        end
+
+        def gc_metrics
+          Core::Environment::GC.stat.flat_map do |k, v|
+            nested_gc_metric(Core::Runtime::Ext::Metrics::METRIC_GC_PREFIX, k, v)
+          end.to_h
+        end
+
+        def try_flush
+          yield
+        rescue StandardError => e
+          Datadog.logger.error("Error while sending runtime metric. Cause: #{e.message}")
+        end
+
+        def default_metric_options
+          # Return dupes, so that the constant isn't modified,
+          # and defaults are unfrozen for mutation in Statsd.
+          super.tap do |options|
+            options[:tags] = options[:tags].dup
+
+            # Add services dynamically because they might change during runtime.
+            options[:tags].concat(service_tags) unless service_tags.nil?
+          end
+        end
+
+        private
+
+        attr_reader \
+          :service_tags,
+          :services
+
+        def compile_service_tags!
+          @service_tags = services.to_a.collect do |service|
+            "#{Core::Runtime::Ext::Metrics::TAG_SERVICE}:#{service}".freeze
+          end
+        end
+
+        def nested_gc_metric(prefix, k, v)
+          path = "#{prefix}.#{k}"
+
+          if v.is_a?(Hash)
+            v.flat_map do |key, value|
+              nested_gc_metric(path, key, value)
+            end
+          else
+            [[to_metric_name(path), v]]
+          end
+        end
+
+        def to_metric_name(str)
+          str.downcase.gsub(/[-\s]/, '_')
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/compression.rb

@@ -0,0 +1,32 @@
+# typed: true
+
+require 'stringio'
+require 'zlib'
+
+module Datadog
+  module Core
+    module Utils
+      # Common database-related utility functions.
+      module Compression
+        module_function
+
+        def gzip(string, level: nil, strategy: nil)
+          sio = StringIO.new
+          sio.binmode
+          gz = Zlib::GzipWriter.new(sio, level, strategy)
+          gz.write(string)
+          gz.close
+          sio.string
+        end
+
+        def gunzip(string, encoding = ::Encoding::ASCII_8BIT)
+          sio = StringIO.new(string)
+          gz = Zlib::GzipReader.new(sio, encoding: encoding)
+          gz.read
+        ensure
+          gz && gz.close
+        end
+      end
+    end
+  end
+end