ddtrace 0.54.0 → 1.0.0

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

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

@@ -0,0 +1,63 @@
+# typed: false
+
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for managing forking behavior
+      module Forking
+        def self.included(base)
+          base.prepend(ClassExtensions) if base.is_a?(Class)
+        end
+
+        def self.extended(base)
+          # Explicitly update PID here because there's a case where
+          # the code path that lazily updates the PID may not be exercised
+          # until after a fork occurs, thus causing the event to be missed.
+          # By eagerly setting this, we avoid this scenario.
+          base.update_fork_pid!
+        end
+
+        def after_fork!
+          if forked?
+            yield
+            update_fork_pid!
+            true
+          else
+            false
+          end
+        end
+
+        def forked?
+          Process.pid != fork_pid
+        end
+
+        def update_fork_pid!
+          @fork_pid = Process.pid
+        end
+
+        def fork_pid
+          @fork_pid ||= Process.pid
+        end
+
+        # Adds additional functionality for Classes that implement Forking
+        module ClassExtensions
+          # Addresses an edge case where forking before invoking #update_fork_pid! on the
+          # object will cause forking to not be detected in the fork when it should have.
+          #
+          # This wrapper prevents this by initializing the fork PID when the object is created.
+          if RUBY_VERSION >= '3'
+            def initialize(*args, **kwargs, &block)
+              super(*args, **kwargs, &block)
+              update_fork_pid!
+            end
+          else
+            def initialize(*args, &block)
+              super(*args, &block)
+              update_fork_pid!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: true
+
+require 'datadog/core/utils/sequence'
+
+module Datadog
+  module Core
+    module Utils
+      # Acts as a unique dictionary of objects
+      class ObjectSet
+        # You can provide a block that defines how the key
+        # for this message type is resolved.
+        def initialize(seed = 0, &block)
+          @sequence = Sequence.new(seed)
+          @items = {}
+          @key_block = block
+        end
+
+        # Submit an array of arguments that define the message.
+        # If they match an existing message, it will return the
+        # matching object. If it doesn't match, it will yield to
+        # the block with the next ID & args given.
+        def fetch(*args)
+          # TODO: Array hashing is **really** expensive, we probably want to get rid of it in the future
+          key = @key_block ? @key_block.call(*args) : args.hash
+          @items[key] ||= yield(@sequence.next, *args)
+        end
+
+        def length
+          @items.length
+        end
+
+        def objects
+          @items.values
+        end
+
+        def freeze
+          super
+          @items.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# typed: true
+
+module Datadog
+  module Core
+    module Utils
+      # Helper class to execute something only once such as not repeating warning logs, and instrumenting classes
+      # only once.
+      #
+      # Thread-safe when used correctly (e.g. be careful of races when lazily initializing instances of this class).
+      #
+      # Note: In its current state, this class is not Ractor-safe.
+      # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives,
+      # including an alternative implementation that is Ractor-safe once spent.
+      class OnlyOnce
+        def initialize
+          @mutex = Mutex.new
+          @ran_once = false
+        end
+
+        def run
+          @mutex.synchronize do
+            return if @ran_once
+
+            @ran_once = true
+
+            yield
+          end
+        end
+
+        def ran?
+          @mutex.synchronize { @ran_once }
+        end
+
+        private
+
+        def reset_ran_once_state_for_tests
+          @mutex.synchronize { @ran_once = false }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# typed: false
+
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for safer dup
+      module SafeDup
+        if RUBY_VERSION < '2.2' # nil.dup only fails in Ruby 2.1
+          # Ensures #initialize can call nil.dup safely
+          module RefineNil
+            refine NilClass do
+              def dup
+                self
+              end
+            end
+          end
+
+          using RefineNil
+        end
+
+        def self.frozen_or_dup(v)
+          v.frozen? ? v : v.dup
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Utils
+      # Generates values from a consistent sequence
+      class Sequence
+        def initialize(seed = 0, &block)
+          @current = seed
+          @next_item = block
+        end
+
+        def next
+          next_item = @next_item ? @next_item.call(@current) : @current
+          @current += 1
+          next_item
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# typed: true
+
+require 'datadog/core/utils/sequence'
+
+module Datadog
+  module Core
+    module Utils
+      # Tracks strings and returns IDs
+      class StringTable
+        def initialize
+          @sequence = Sequence.new
+          @ids = { ''.freeze => @sequence.next }
+        end
+
+        # Returns an ID for the string
+        def fetch(string)
+          @ids[string.to_s] ||= @sequence.next
+        end
+
+        # Returns the canonical copy of this string
+        # Typically used for psuedo interning; reduce
+        # identical copies of a string to one object.
+        def fetch_string(string)
+          return nil if string.nil?
+
+          # Co-erce to string
+          string = string.to_s
+
+          # Add to string table if no match
+          @ids[string] = @sequence.next unless @ids.key?(string)
+
+          # Get and return matching string in table
+          # NOTE: Have to resolve the key and retrieve from table again
+          #       because "string" argument is not same object as string key.
+          id = @ids[string]
+          @ids.key(id)
+        end
+
+        def [](id)
+          @ids.key(id)
+        end
+
+        def strings
+          @ids.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Utils
+      # Common database-related utility functions.
+      module Time
+        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+        module_function
+
+        # Current monotonic time
+        #
+        # @param unit [Symbol] unit for the resulting value, same as ::Process#clock_gettime, defaults to :float_second
+        # @return [Numeric] timestamp in the requested unit, since some unspecified starting point
+        def get_time(unit = :float_second)
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+        end
+
+        # Current wall time.
+        #
+        # @return [Time] current time object
+        def now
+          ::Time.now
+        end
+
+        # Overrides the implementation of `#now
+        # with the provided callable.
+        #
+        # Overriding the method `#now` instead of
+        # indirectly calling `block` removes
+        # one level of method call overhead.
+        #
+        # @param block [Proc] block that returns a `Time` object representing the current wall time
+        def now_provider=(block)
+          define_singleton_method(:now, &block)
+        end
+
+        def measure
+          before = get_time
+          yield
+          after = get_time
+          after - before
+        end
+
+        def as_utc_epoch_ns(time)
+          # we use #to_r instead of #to_f because Float doesn't have enough precision to represent exact nanoseconds, see
+          # https://rubyapi.org/3.0/o/time#method-i-to_f
+          (time.to_r * 1_000_000_000).to_i
+        end
+      end
+    end
+  end
+end