datadog 2.4.0 → 2.44.0

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Utils
-      # Helper methods for encoding and decoding base64
-      module Base64
-        def self.encode64(bin)
-          [bin].pack('m')
-        end
-
-        def self.strict_encode64(bin)
-          [bin].pack('m0')
-        end
-
-        def self.strict_decode64(str)
-          str.unpack1('m0')
-        end
-      end
-    end
-  end
-end

data/lib/datadog/di/configuration/settings.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module DI
-    module Configuration
-      # Settings
-      module Settings
-        def self.extended(base)
-          base = base.singleton_class unless base.is_a?(Class)
-          add_settings!(base)
-        end
-
-        def self.add_settings!(base)
-          base.class_eval do
-            # The setting has "internal" prefix to prevent it from being
-            # prematurely turned on by customers.
-            settings :dynamic_instrumentation do
-              option :enabled do |o|
-                o.type :bool
-                # The environment variable has an "internal" prefix so that
-                # any customers that have the "proper" environment variable
-                # turned on (i.e. DD_DYNAMIC_INSTRUMENTATION_ENABLED)
-                # do not enable Ruby DI until the latter is ready for
-                # customer testing.
-                o.env "DD_DYNAMIC_INSTRUMENTATION_ENABLED"
-                o.default false
-              end
-
-              # This option instructs dynamic instrumentation to use
-              # untargeted trace points when installing line probes and
-              # code tracking is not active.
-              # WARNING: untargeted trace points carry a massive performance
-              # penalty for the entire file in which a line probe is placed.
-              #
-              # If this option is set to false, which is the default,
-              # dynamic instrumentation will add probes that reference
-              # unknown files to the list of pending probes, and when
-              # the respective files are loaded, the line probes will be
-              # installed using targeted trace points. If the file in
-              # question is already loaded when the probe is received
-              # (for example, it is in a third-party library loaded during
-              # application boot), and code tracking was not active when
-              # the file was loaded, such files will not be instrumentable
-              # via line probes.
-              #
-              # If this option is set to true
-              #
-              # activated, DI will in
-              # activated or because the files being targeted have beenIf true and code tracking is not enabled, dynamic instrumentation
-              # will use untargeted trace points.
-              # If false and code tracking is not enabled, dynamic
-              # instrumentation will not instrument any files loaded
-              # WARNING: these trace points will greatly degrade performance
-              # of all code in the instrumented files.
-              option :untargeted_trace_points do |o|
-                o.type :bool
-                o.default false
-              end
-
-              # If true, all of the catch-all rescue blocks in DI
-              # will propagate the exceptions onward.
-              # WARNING: for internal Datadog use only - this will break
-              # the DI product and potentially the library in general in
-              # a multitude of ways, cause resource leakage, permanent
-              # performance decreases, etc.
-              option :propagate_all_exceptions do |o|
-                o.type :bool
-                o.default false
-              end
-
-              # An array of variable and key names to redact in addition to
-              # the built-in list of identifiers.
-              #
-              # The names will be normalized by removing the following
-              # symbols: _, -, @, $, and then matched to the complete
-              # variable or key name while ignoring the case.
-              # For example, specifying pass_word will match password and
-              # PASSWORD, and specifying PASSWORD will match pass_word.
-              # Note that, while the at sign (@) is used in Ruby to refer
-              # to instance variables, it does not have any significance
-              # for this setting (and is removed before matching identifiers).
-              option :redacted_identifiers do |o|
-                o.env "DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS"
-                o.env_parser do |value|
-                  value&.split(",")&.map(&:strip)
-                end
-
-                o.type :array
-                o.default []
-              end
-
-              # An array of class names, values of which will be redacted from
-              # dynamic instrumentation snapshots. Example: FooClass.
-              # If a name is suffixed by '*', it becomes a wildcard and
-              # instances of any class whose name begins with the specified
-              # prefix will be redacted (example: Foo*).
-              #
-              # The names must all be fully-qualified, if any prefix of a
-              # class name is configured to be redacted, the value will be
-              # subject to redaction. For example, if Foo* is in the
-              # redacted class name list, instances of Foo, FooBar,
-              # Foo::Bar are all subject to redaction, but Bar::Foo will
-              # not be subject to redaction.
-              #
-              # Leading double-colon is permitted but has no effect,
-              # because the names are always considered to be fully-qualified.
-              # For example, adding ::Foo to the list will redact instances
-              # of Foo.
-              #
-              # Trailing colons should not be used because they will trigger
-              # exact match behavior but Ruby class names do not have
-              # trailing colons. For example, Foo:: will not cause anything
-              # to be redacted. Use Foo::* to redact all classes under
-              # the Foo module.
-              option :redacted_type_names do |o|
-                o.env "DD_DYNAMIC_INSTRUMENTATION_REDACTED_TYPES"
-                o.env_parser do |value|
-                  value&.split(",")&.map(&:strip)
-                end
-
-                o.type :array
-                o.default []
-              end
-
-              # Maximum number of object or collection traversals that
-              # will be permitted when serializing captured values.
-              option :max_capture_depth do |o|
-                o.type :int
-                o.default 3
-              end
-
-              # Maximum number of collection (Array and Hash) elements
-              # that will be captured. Arrays and hashes that have more
-              # elements will be truncated to this many elements.
-              option :max_capture_collection_size do |o|
-                o.type :int
-                o.default 100
-              end
-
-              # Strings longer than this length will be truncated to this
-              # length in dynamic instrumentation snapshots.
-              #
-              # Note that while all values are stringified during
-              # serialization, only values which are originally instances
-              # of the String class are subject to this length limit.
-              option :max_capture_string_length do |o|
-                o.type :int
-                o.default 255
-              end
-
-              # Maximim number of attributes that will be captured for
-              # a single non-primitive value.
-              option :max_capture_attribute_count do |o|
-                o.type :int
-                o.default 20
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/contrib/rails/utils.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../analytics'
-
-module Datadog
-  module Tracing
-    module Contrib
-      module Rails
-        # common utilities for Rails
-        module Utils
-          def self.app_name
-            if ::Rails::VERSION::MAJOR >= 6
-              ::Rails.application.class.module_parent_name.underscore
-            else
-              ::Rails.application.class.parent_name.underscore
-            end
-          end
-
-          def self.railtie_supported?
-            !!defined?(::Rails::Railtie)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/datadog_tags_codec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Tracing
-    module Distributed
-      # Encodes and decodes distributed 'x-datadog-tags' tags for transport
-      # to and from external processes.
-      module DatadogTagsCodec
-        # Backport `Regexp::match?` because it is measurably the most performant
-        # way to check if a string matches a regular expression.
-        module RefineRegexp
-          unless Regexp.method_defined?(:match?)
-            refine ::Regexp do
-              def match?(*args)
-                !match(*args).nil?
-              end
-            end
-          end
-        end
-        using RefineRegexp
-
-        # ASCII characters 32-126, except `,`, `=`, and ` `. At least one character.
-        VALID_KEY_CHARS = /\A(?:(?![,= ])[\u0020-\u007E])+\Z/.freeze
-        # ASCII characters 32-126, except `,`. At least one character.
-        VALID_VALUE_CHARS = /\A(?:(?!,)[\u0020-\u007E])+\Z/.freeze
-
-        # Serializes a {Hash<String,String>} into a `x-datadog-tags`-compatible
-        # String.
-        #
-        # @param tags [Hash<String,String>] trace tag hash
-        # @return [String] serialized tags hash
-        # @raise [EncodingError] if tags cannot be serialized to the `x-datadog-tags` format
-        def self.encode(tags)
-          begin
-            tags.map do |raw_key, raw_value|
-              key = raw_key.to_s
-              value = raw_value.to_s
-
-              raise EncodingError, "Invalid key `#{key}` for value `#{value}`" unless VALID_KEY_CHARS.match?(key)
-              raise EncodingError, "Invalid value `#{value}` for key `#{key}`" unless VALID_VALUE_CHARS.match?(value)
-
-              "#{key}=#{value.strip}"
-            end.join(',')
-          rescue => e
-            raise EncodingError, "Error encoding tags `#{tags}`: `#{e}`"
-          end
-        end
-
-        # Deserializes a `x-datadog-tags`-formatted String into a {Hash<String,String>}.
-        #
-        # @param string [String] tags as serialized by {#encode}
-        # @return [Hash<String,String>] decoded input as a hash of strings
-        # @raise [DecodingError] if string does not conform to the `x-datadog-tags` format
-        def self.decode(string)
-          result = Hash[string.split(',').map do |raw_tag|
-            raw_tag.split('=', 2).tap do |raw_key, raw_value|
-              key = raw_key.to_s
-              value = raw_value.to_s
-
-              raise DecodingError, "Invalid key: #{key}" unless VALID_KEY_CHARS.match?(key)
-              raise DecodingError, "Invalid value: #{value}" unless VALID_VALUE_CHARS.match?(value)
-
-              value.strip!
-            end
-          end]
-
-          raise DecodingError, "Invalid empty tags: #{string}" if result.empty? && !string.empty?
-
-          result
-        end
-
-        # An error occurred during distributed tags encoding.
-        # See {#message} for more information.
-        class EncodingError < StandardError
-        end
-
-        # An error occurred during distributed tags decoding.
-        # See {#message} for more information.
-        class DecodingError < StandardError
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/transport/http/api/spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Tracing
-    module Transport
-      module HTTP
-        module API
-          # Specification for an HTTP API
-          # Defines behaviors without specific configuration details.
-          class Spec
-            def initialize
-              yield(self) if block_given?
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/transport/http/api.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../core/encoding'
-
-require_relative '../../../core/transport/http/api/map'
-require_relative 'api/spec'
-
-require_relative 'traces'
-
-module Datadog
-  module Tracing
-    module Transport
-      module HTTP
-        # Namespace for API components
-        module API
-          # Default API versions
-          V4 = 'v0.4'
-          V3 = 'v0.3'
-
-          module_function
-
-          def defaults
-            Datadog::Core::Transport::HTTP::API::Map[
-              V4 => Spec.new do |s|
-                s.traces = Traces::API::Endpoint.new(
-                  '/v0.4/traces',
-                  Core::Encoding::MsgpackEncoder,
-                  service_rates: true
-                )
-              end,
-              V3 => Spec.new do |s|
-                s.traces = Traces::API::Endpoint.new(
-                  '/v0.3/traces',
-                  Core::Encoding::MsgpackEncoder
-                )
-              end,
-            ].with_fallbacks(V4 => V3)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/workers/trace_writer.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../core/worker'
-require_relative '../../core/workers/async'
-require_relative '../../core/workers/polling'
-require_relative '../../core/workers/queue'
-
-require_relative '../buffer'
-require_relative '../pipeline'
-require_relative '../event'
-
-require_relative '../transport/http'
-
-module Datadog
-  module Tracing
-    module Workers
-      # Writes traces to transport synchronously
-      class TraceWriter < Core::Worker
-        attr_reader \
-          :transport
-
-        # rubocop:disable Lint/MissingSuper
-        def initialize(options = {})
-          transport_options = options.fetch(:transport_options, {})
-
-          transport_options[:agent_settings] = options[:agent_settings] if options.key?(:agent_settings)
-
-          @transport = options.fetch(:transport) do
-            Datadog::Tracing::Transport::HTTP.default(**transport_options)
-          end
-        end
-        # rubocop:enable Lint/MissingSuper
-
-        def perform(traces)
-          write_traces(traces)
-        end
-
-        def write(trace)
-          write_traces([trace])
-        end
-
-        def write_traces(traces)
-          traces = process_traces(traces)
-          flush_traces(traces)
-        rescue StandardError => e
-          Datadog.logger.warn(
-            "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
-          )
-        end
-
-        def process_traces(traces)
-          # Run traces through the processing pipeline
-          Pipeline.process!(traces)
-        end
-
-        def flush_traces(traces)
-          transport.send_traces(traces).tap do |response|
-            flush_completed.publish(response)
-          end
-        end
-
-        # TODO: Register `Datadog::Tracing::Diagnostics::EnvironmentLogger.collect_and_log!`
-        # TODO: as a flush_completed subscriber when the `TraceWriter`
-        # TODO: instantiation code is implemented.
-        def flush_completed
-          @flush_completed ||= FlushCompleted.new
-        end
-
-        # Flush completed event for worker
-        class FlushCompleted < Event
-          def initialize
-            super(:flush_completed)
-          end
-        end
-      end
-
-      # Writes traces to transport asynchronously,
-      # using a thread & buffer.
-      class AsyncTraceWriter < TraceWriter
-        include Core::Workers::Queue
-        include Core::Workers::Polling
-
-        DEFAULT_BUFFER_MAX_SIZE = 1000
-        FORK_POLICY_ASYNC = :async
-        FORK_POLICY_SYNC = :sync
-
-        attr_writer \
-          :async
-
-        def initialize(options = {})
-          # Workers::TraceWriter settings
-          super
-
-          # Workers::Polling settings
-          self.enabled = options.fetch(:enabled, true)
-
-          # Workers::Async::Thread settings
-          @async = true
-          self.fork_policy = options.fetch(:fork_policy, FORK_POLICY_ASYNC)
-
-          # Workers::IntervalLoop settings
-          self.loop_base_interval = options[:interval] if options.key?(:interval)
-          self.loop_back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
-          self.loop_back_off_max = options[:back_off_max] if options.key?(:back_off_max)
-
-          # Workers::Queue settings
-          @buffer_size = options.fetch(:buffer_size, DEFAULT_BUFFER_MAX_SIZE)
-          self.buffer = TraceBuffer.new(@buffer_size)
-
-          @shutdown_timeout = options.fetch(:shutdown_timeout, Core::Workers::Polling::DEFAULT_SHUTDOWN_TIMEOUT)
-        end
-
-        # NOTE: #perform is wrapped by other modules:
-        #       Polling --> Async --> IntervalLoop --> AsyncTraceWriter --> TraceWriter
-        #
-        # WARNING: This method breaks the Liskov Substitution Principle -- TraceWriter#perform is spec'd to return the
-        # result from the writer, whereas this method always returns nil.
-        def perform(traces)
-          super(traces).tap do |responses|
-            loop_back_off! if responses.find(&:server_error?)
-          end
-
-          nil
-        end
-
-        def stop(force_stop = false, timeout = @shutdown_timeout)
-          buffer.close if running?
-          super
-        end
-
-        def enqueue(trace)
-          buffer.push(trace)
-        end
-
-        def dequeue
-          # Wrap results in Array because they are
-          # splatted as args against TraceWriter#perform.
-          [buffer.pop]
-        end
-
-        # Are there more traces to be processed next?
-        def work_pending?
-          !buffer.empty?
-        end
-
-        def async?
-          @async == true
-        end
-
-        def fork_policy=(policy)
-          # Translate to Workers::Async::Thread policy
-          thread_fork_policy =  case policy
-                                when Core::Workers::Async::Thread::FORK_POLICY_STOP
-                                  policy
-                                when FORK_POLICY_SYNC
-                                  # Stop the async thread because the writer
-                                  # will bypass and run synchronously.
-                                  Core::Workers::Async::Thread::FORK_POLICY_STOP
-                                else
-                                  Core::Workers::Async::Thread::FORK_POLICY_RESTART
-                                end
-
-          # Update thread fork policy
-          super(thread_fork_policy)
-
-          # Update local policy
-          @writer_fork_policy = policy
-        end
-
-        def after_fork
-          # In multiprocess environments, forks will share the same buffer until its written to.
-          # A.K.A. copy-on-write. We don't want forks to write traces generated from another process.
-          # Instead, we reset it after the fork. (Make sure any enqueue operations happen after this.)
-          self.buffer = TraceBuffer.new(@buffer_size)
-
-          # Switch to synchronous mode if configured to do so.
-          # In some cases synchronous writing is preferred because the fork will be short lived.
-          @async = false if @writer_fork_policy == FORK_POLICY_SYNC
-        end
-
-        # WARNING: This method breaks the Liskov Substitution Principle -- TraceWriter#write is spec'd to return the
-        # result from the writer, whereas this method returns something else when running in async mode.
-        def write(trace)
-          # Start worker thread. If the process has forked, it will trigger #after_fork to
-          # reconfigure the worker accordingly.
-          # NOTE: It's important we do this before queuing or it will drop the current trace,
-          #       because #after_fork resets the buffer.
-          perform
-
-          # Queue the trace if running asynchronously, otherwise short-circuit and write it directly.
-          async? ? enqueue(trace) : write_traces([trace])
-        end
-      end
-    end
-  end
-end