ddtrace 0.49.0 → 1.12.1

data/lib/ddtrace/diagnostics/environment_logger.rb

@@ -1,279 +0,0 @@
-require 'date'
-require 'json'
-require 'rbconfig'
-
-module Datadog
-  module Diagnostics
-    # A holistic collection of the environment in which ddtrace is running.
-    # This logger should allow for easy reporting by users to Datadog support.
-    #
-    module EnvironmentLogger
-      class << self
-        # Outputs environment information to {Datadog.logger}.
-        # Executes only for the lifetime of the program.
-        def log!(transport_responses)
-          return if (defined?(@executed) && @executed) || !log?
-
-          @executed = true
-
-          data = EnvironmentCollector.new.collect!(transport_responses)
-          data.reject! { |_, v| v.nil? } # Remove empty values from hash output
-
-          log_environment!(data.to_json)
-          log_error!('Agent Error'.freeze, data[:agent_error]) if data[:agent_error]
-        rescue => e
-          Datadog.logger.warn("Failed to collect environment information: #{e} location: #{e.backtrace.first}")
-        end
-
-        private
-
-        def log_environment!(line)
-          Datadog.logger.info("DATADOG TRACER CONFIGURATION - #{line}")
-        end
-
-        def log_error!(type, error)
-          Datadog.logger.warn("DATADOG TRACER DIAGNOSTIC - #{type}: #{error}")
-        end
-
-        # Are we logging the environment data?
-        def log?
-          startup_logs_enabled = Datadog.configuration.diagnostics.startup_logs.enabled
-          if startup_logs_enabled.nil?
-            !repl? # Suppress logs if we running in a REPL
-          else
-            startup_logs_enabled
-          end
-        end
-
-        REPL_PROGRAM_NAMES = %w[irb pry].freeze
-
-        def repl?
-          REPL_PROGRAM_NAMES.include?($PROGRAM_NAME)
-        end
-      end
-    end
-
-    # Collects environment information for diagnostic logging
-    class EnvironmentCollector
-      # @return [String] current time in ISO8601 format
-      def date
-        DateTime.now.iso8601
-      end
-
-      # Best portable guess of OS information.
-      # @return [String] platform string
-      def os_name
-        RbConfig::CONFIG['host'.freeze]
-      end
-
-      # @return [String] ddtrace version
-      def version
-        VERSION::STRING
-      end
-
-      # @return [String] "ruby"
-      def lang
-        Ext::Runtime::LANG
-      end
-
-      # Supported Ruby language version.
-      # Will be distinct from VM version for non-MRI environments.
-      # @return [String]
-      def lang_version
-        Ext::Runtime::LANG_VERSION
-      end
-
-      # @return [String] configured application environment
-      def env
-        Datadog.configuration.env
-      end
-
-      # @return [Boolean, nil]
-      def enabled
-        Datadog.configuration.tracer.enabled
-      end
-
-      # @return [String] configured application service name
-      def service
-        Datadog.configuration.service
-      end
-
-      # @return [String] configured application version
-      def dd_version
-        Datadog.configuration.version
-      end
-
-      # @return [String] target agent URL for trace flushing
-      def agent_url
-        # Retrieve the effect agent URL, regardless of how it was configured
-        transport = Datadog.tracer.writer.transport
-        adapter = transport.client.api.adapter
-        adapter.url
-      end
-
-      # Error returned by Datadog agent during a tracer flush attempt
-      # @return [String] concatenated list of transport errors
-      def agent_error(transport_responses)
-        error_responses = transport_responses.reject(&:ok?)
-
-        return nil if error_responses.empty?
-
-        error_responses.map(&:inspect).join(','.freeze)
-      end
-
-      # @return [Boolean, nil] debug mode enabled in configuration
-      def debug
-        !!Datadog.configuration.diagnostics.debug
-      end
-
-      # @return [Boolean, nil] analytics enabled in configuration
-      def analytics_enabled
-        !!Datadog.configuration.analytics.enabled
-      end
-
-      # @return [Numeric, nil] tracer sample rate configured
-      def sample_rate
-        sampler = Datadog.configuration.tracer.sampler
-        return nil unless sampler
-
-        sampler.sample_rate(nil) rescue nil
-      end
-
-      # DEV: We currently only support SimpleRule instances.
-      # DEV: These are the most commonly used rules.
-      # DEV: We should expand support for other rules in the future,
-      # DEV: although it is tricky to serialize arbitrary rules.
-      #
-      # @return [Hash, nil] sample rules configured
-      def sampling_rules
-        sampler = Datadog.configuration.tracer.sampler
-        return nil unless sampler.is_a?(Datadog::PrioritySampler) &&
-                          sampler.priority_sampler.is_a?(Datadog::Sampling::RuleSampler)
-
-        sampler.priority_sampler.rules.map do |rule|
-          next unless rule.is_a?(Datadog::Sampling::SimpleRule)
-
-          {
-            name: rule.matcher.name,
-            service: rule.matcher.service,
-            sample_rate: rule.sampler.sample_rate(nil)
-          }
-        end.compact
-      end
-
-      # @return [Hash, nil] concatenated list of global tracer tags configured
-      def tags
-        tags = Datadog.configuration.tags
-        return nil if tags.empty?
-
-        hash_serializer(tags)
-      end
-
-      # @return [Boolean, nil] runtime metrics enabled in configuration
-      def runtime_metrics_enabled
-        Datadog.configuration.runtime_metrics.enabled
-      end
-
-      # Concatenated list of integrations activated, with their gem version.
-      # Example: "rails@6.0.3,rack@2.2.3"
-      #
-      # @return [String, nil]
-      def integrations_loaded
-        integrations = instrumented_integrations
-        return if integrations.empty?
-
-        integrations.map { |name, integration| "#{name}@#{integration.class.version}" }.join(','.freeze)
-      end
-
-      # Ruby VM name and version.
-      # Examples: "ruby-2.7.1", "jruby-9.2.11.1", "truffleruby-20.1.0"
-      # @return [String, nil]
-      def vm
-        # RUBY_ENGINE_VERSION returns the VM version, which
-        # will differ from RUBY_VERSION for non-mri VMs.
-        if defined?(RUBY_ENGINE_VERSION)
-          "#{RUBY_ENGINE}-#{RUBY_ENGINE_VERSION}"
-        else
-          # Ruby < 2.3 doesn't support RUBY_ENGINE_VERSION
-          "#{RUBY_ENGINE}-#{RUBY_VERSION}"
-        end
-      end
-
-      # @return [Boolean, nil] partial flushing enabled in configuration
-      def partial_flushing_enabled
-        !!Datadog.configuration.tracer.partial_flush.enabled
-      end
-
-      # @return [Boolean, nil] priority sampling enabled in configuration
-      def priority_sampling_enabled
-        !!Datadog.configuration.tracer.priority_sampling
-      end
-
-      # @return [Boolean, nil] health metrics enabled in configuration
-      def health_metrics_enabled
-        !!Datadog.configuration.diagnostics.health_metrics.enabled
-      end
-
-      # TODO: Populate when profiling is implemented
-      # def profiling_enabled
-      # end
-
-      # TODO: Populate when automatic log correlation is implemented
-      # def logs_correlation_enabled
-      # end
-
-      # @return [Hash] environment information available at call time
-      def collect!(transport_responses)
-        {
-          date: date,
-          os_name: os_name,
-          version: version,
-          lang: lang,
-          lang_version: lang_version,
-          env: env,
-          enabled: enabled,
-          service: service,
-          dd_version: dd_version,
-          agent_url: agent_url,
-          agent_error: agent_error(transport_responses),
-          debug: debug,
-          analytics_enabled: analytics_enabled,
-          sample_rate: sample_rate,
-          sampling_rules: sampling_rules,
-          tags: tags,
-          runtime_metrics_enabled: runtime_metrics_enabled,
-          integrations_loaded: integrations_loaded,
-          vm: vm,
-          partial_flushing_enabled: partial_flushing_enabled,
-          priority_sampling_enabled: priority_sampling_enabled,
-          health_metrics_enabled: health_metrics_enabled,
-          **instrumented_integrations_settings
-        }
-      end
-
-      private
-
-      def instrumented_integrations
-        Datadog.configuration.instrumented_integrations
-      end
-
-      # Capture all active integration settings into "integrationName_settingName: value" entries.
-      def instrumented_integrations_settings
-        Hash[instrumented_integrations.flat_map do |name, integration|
-          integration.configuration.to_h.flat_map do |setting, value|
-            next [] if setting == :tracer # Skip internal Ruby objects
-
-            # Convert value to a string to avoid custom #to_json
-            # handlers possibly causing errors.
-            [[:"integration_#{name}_#{setting}", value.to_s]]
-          end
-        end]
-      end
-
-      # Outputs "k1:v1,k2:v2,..."
-      def hash_serializer(h)
-        h.map { |k, v| "#{k}:#{v}" }.join(','.freeze)
-      end
-    end
-  end
-end

data/lib/ddtrace/diagnostics/health.rb

@@ -1,33 +0,0 @@
-require 'ddtrace/ext/diagnostics'
-require 'ddtrace/metrics'
-
-module Datadog
-  module Diagnostics
-    # Health-related diagnostics
-    module Health
-      # Health metrics for diagnostics
-      class Metrics < ::Datadog::Metrics
-        count :api_errors, Ext::Diagnostics::Health::Metrics::METRIC_API_ERRORS
-        count :api_requests, Ext::Diagnostics::Health::Metrics::METRIC_API_REQUESTS
-        count :api_responses, Ext::Diagnostics::Health::Metrics::METRIC_API_RESPONSES
-        count :error_context_overflow, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_CONTEXT_OVERFLOW
-        count :error_instrumentation_patch, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_INSTRUMENTATION_PATCH
-        count :error_span_finish, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_SPAN_FINISH
-        count :error_unfinished_spans, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_UNFINISHED_SPANS
-        count :instrumentation_patched, Ext::Diagnostics::Health::Metrics::METRIC_INSTRUMENTATION_PATCHED
-        count :queue_accepted, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED
-        count :queue_accepted_lengths, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED_LENGTHS
-        count :queue_dropped, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_DROPPED
-        count :traces_filtered, Ext::Diagnostics::Health::Metrics::METRIC_TRACES_FILTERED
-        count :transport_trace_too_large, Ext::Diagnostics::Health::Metrics::METRIC_TRANSPORT_TRACE_TOO_LARGE
-        count :transport_chunked, Ext::Diagnostics::Health::Metrics::METRIC_TRANSPORT_CHUNKED
-        count :writer_cpu_time, Ext::Diagnostics::Health::Metrics::METRIC_WRITER_CPU_TIME
-
-        gauge :queue_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_LENGTH
-        gauge :queue_max_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_MAX_LENGTH
-        gauge :queue_spans, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_SPANS
-        gauge :sampling_service_cache_length, Ext::Diagnostics::Health::Metrics::METRIC_SAMPLING_SERVICE_CACHE_LENGTH
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/b3.rb

@@ -1,44 +0,0 @@
-require 'ddtrace/ext/distributed'
-require 'ddtrace/distributed_tracing/headers/headers'
-require 'ddtrace/distributed_tracing/headers/helpers'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # B3 provides helpers to inject or extract headers for B3 style headers
-      module B3
-        include Ext::DistributedTracing
-
-        def self.inject!(context, env)
-          return if context.nil?
-
-          # DEV: We need these to be hex encoded
-          env[B3_HEADER_TRACE_ID] = context.trace_id.to_s(16)
-          env[B3_HEADER_SPAN_ID] = context.span_id.to_s(16)
-
-          unless context.sampling_priority.nil?
-            sampling_priority = DistributedTracing::Headers::Helpers.clamp_sampling_priority(context.sampling_priority)
-            env[B3_HEADER_SAMPLED] = sampling_priority.to_s
-          end
-        end
-
-        def self.extract(env)
-          # Extract values from headers
-          # DEV: B3 doesn't have "origin"
-          headers = Headers.new(env)
-          trace_id = headers.id(B3_HEADER_TRACE_ID, 16)
-          span_id = headers.id(B3_HEADER_SPAN_ID, 16)
-          # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
-          sampling_priority = headers.number(B3_HEADER_SAMPLED)
-
-          # Return early if this propagation is not valid
-          return unless trace_id && span_id
-
-          ::Datadog::Context.new(trace_id: trace_id,
-                                 span_id: span_id,
-                                 sampling_priority: sampling_priority)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/b3_single.rb

@@ -1,56 +0,0 @@
-require 'ddtrace/ext/distributed'
-require 'ddtrace/distributed_tracing/headers/headers'
-require 'ddtrace/distributed_tracing/headers/helpers'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # B3Single provides helpers to inject or extract headers for B3 single header style headers
-      module B3Single
-        include Ext::DistributedTracing
-
-        def self.inject!(context, env)
-          return if context.nil?
-
-          # Header format:
-          #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
-          # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
-          # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
-
-          # DEV: We need these to be hex encoded
-          header = "#{context.trace_id.to_s(16)}-#{context.span_id.to_s(16)}"
-
-          unless context.sampling_priority.nil?
-            sampling_priority = DistributedTracing::Headers::Helpers.clamp_sampling_priority(context.sampling_priority)
-            header += "-#{sampling_priority}"
-          end
-
-          env[B3_HEADER_SINGLE] = header
-        end
-
-        def self.extract(env)
-          # Header format:
-          #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
-          # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
-          # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
-
-          headers = Headers.new(env)
-          value = headers.header(B3_HEADER_SINGLE)
-          return if value.nil?
-
-          parts = value.split('-')
-          trace_id = headers.value_to_id(parts[0], 16) unless parts.empty?
-          span_id = headers.value_to_id(parts[1], 16) if parts.length > 1
-          sampling_priority = headers.value_to_number(parts[2]) if parts.length > 2
-
-          # Return early if this propagation is not valid
-          return unless trace_id && span_id
-
-          ::Datadog::Context.new(trace_id: trace_id,
-                                 span_id: span_id,
-                                 sampling_priority: sampling_priority)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/datadog.rb

@@ -1,42 +0,0 @@
-require 'ddtrace/ext/distributed'
-require 'ddtrace/distributed_tracing/headers/headers'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # Datadog provides helpers to inject or extract headers for Datadog style headers
-      module Datadog
-        include Ext::DistributedTracing
-
-        def self.inject!(context, env)
-          return if context.nil?
-
-          env[HTTP_HEADER_TRACE_ID] = context.trace_id.to_s
-          env[HTTP_HEADER_PARENT_ID] = context.span_id.to_s
-          env[HTTP_HEADER_SAMPLING_PRIORITY] = context.sampling_priority.to_s unless context.sampling_priority.nil?
-          env[HTTP_HEADER_ORIGIN] = context.origin.to_s unless context.origin.nil?
-        end
-
-        def self.extract(env)
-          # Extract values from headers
-          headers = Headers.new(env)
-          trace_id = headers.id(HTTP_HEADER_TRACE_ID)
-          parent_id = headers.id(HTTP_HEADER_PARENT_ID)
-          origin = headers.header(HTTP_HEADER_ORIGIN)
-          sampling_priority = headers.number(HTTP_HEADER_SAMPLING_PRIORITY)
-
-          # Return early if this propagation is not valid
-          # DEV: To be valid we need to have a trace id and a parent id or when it is a synthetics trace, just the trace id
-          # DEV: `DistributedHeaders#id` will not return 0
-          return unless (trace_id && parent_id) || (origin && trace_id)
-
-          # Return new context
-          ::Datadog::Context.new(trace_id: trace_id,
-                                 span_id: parent_id,
-                                 origin: origin,
-                                 sampling_priority: sampling_priority)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/headers.rb

@@ -1,71 +0,0 @@
-require 'ddtrace/configuration'
-require 'ddtrace/span'
-require 'ddtrace/ext/distributed'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # Headers provides easy access and validation methods for Rack headers
-      class Headers
-        include Ext::DistributedTracing
-
-        def initialize(env)
-          @env = env
-        end
-
-        # TODO: Don't assume Rack format.
-        #       Make distributed tracing headers apathetic.
-        def header(name)
-          rack_header = "http-#{name}".upcase!.tr('-', '_')
-
-          hdr = @env[rack_header]
-
-          # Only return the value if it is not an empty string
-          hdr if hdr != ''
-        end
-
-        def id(hdr, base = 10)
-          value_to_id(header(hdr), base)
-        end
-
-        def value_to_id(value, base = 10)
-          id = value_to_number(value, base)
-
-          # Return early if we could not parse a number
-          return if id.nil?
-
-          # Zero or greater than max allowed value of 2**64
-          return if id.zero? || id > Span::EXTERNAL_MAX_ID
-
-          id < 0 ? id + (2**64) : id
-        end
-
-        def number(hdr, base = 10)
-          value_to_number(header(hdr), base)
-        end
-
-        def value_to_number(value, base = 10)
-          # It's important to make a difference between no header,
-          # and a header defined to zero.
-          return if value.nil?
-
-          # Be sure we have a string
-          value = value.to_s
-
-          # If we are parsing base16 number then truncate to 64-bit
-          value = DistributedTracing::Headers::Helpers.truncate_base16_number(value) if base == 16
-
-          # Convert header to an integer
-          # DEV: Ruby `.to_i` will return `0` if a number could not be parsed
-          num = value.to_i(base)
-
-          # Ensure the parsed number is the same as the original string value
-          # e.g. We want to make sure to throw away `'nan'.to_i == 0`
-          return unless num.to_s(base) == value
-
-          num
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/helpers.rb

@@ -1,43 +0,0 @@
-require 'ddtrace/configuration'
-require 'ddtrace/span'
-require 'ddtrace/ext/priority'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # Helpers module provides common helper functions for distributed tracing headers
-      module Helpers
-        # Base provides common methods for distributed header helper classes
-        def self.clamp_sampling_priority(sampling_priority)
-          # B3 doesn't have our -1 (USER_REJECT) and 2 (USER_KEEP) priorities so convert to acceptable 0/1
-          if sampling_priority < 0
-            sampling_priority = Ext::Priority::AUTO_REJECT
-          elsif sampling_priority > 1
-            sampling_priority = Ext::Priority::AUTO_KEEP
-          end
-
-          sampling_priority
-        end
-
-        def self.truncate_base16_number(value)
-          # Lowercase if we want to parse base16 e.g. 3E8 => 3e8
-          # DEV: Ruby will parse `3E8` just fine, but to test
-          #      `num.to_s(base) == value` we need to lowercase
-          value = value.downcase
-
-          # Truncate to trailing 16 characters if length is greater than 16
-          # https://github.com/apache/incubator-zipkin/blob/21fe362899fef5c593370466bc5707d3837070c2/zipkin/src/main/java/zipkin2/storage/StorageComponent.java#L49-L53
-          # DEV: This ensures we truncate B3 128-bit trace and span ids to 64-bit
-          value = value[value.length - 16, 16] if value.length > 16
-
-          # Remove any leading zeros
-          # DEV: When we call `num.to_s(16)` later Ruby will not add leading zeros
-          #      for us so we want to make sure the comparision will work as expected
-          # DEV: regex, remove all leading zeros up until we find the last 0 in the string
-          #      or we find the first non-zero, this allows `'0000' -> '0'` and `'00001' -> '1'`
-          value.sub(/^0*(?=(0$)|[^0])/, '')
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/encoding.rb

@@ -1,69 +0,0 @@
-require 'json'
-require 'msgpack'
-
-module Datadog
-  # Encoding module that encodes data for the AgentTransport
-  module Encoding
-    # Encoder interface that provides the logic to encode traces and service
-    module Encoder
-      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

data/lib/ddtrace/environment.rb

@@ -1,41 +0,0 @@
-require 'ddtrace/ext/environment'
-
-module Datadog
-  # Namespace for handling application environment
-  module Environment
-    # Defines helper methods for environment
-    module Helpers
-      def env_to_bool(var, default = nil)
-        var = decode_array(var)
-        var && ENV.key?(var) ? ENV[var].to_s.strip.downcase == 'true' : default
-      end
-
-      def env_to_int(var, default = nil)
-        var = decode_array(var)
-        var && ENV.key?(var) ? ENV[var].to_i : default
-      end
-
-      def env_to_float(var, default = nil)
-        var = decode_array(var)
-        var && ENV.key?(var) ? ENV[var].to_f : default
-      end
-
-      def env_to_list(var, default = [])
-        var = decode_array(var)
-        if var && ENV.key?(var)
-          ENV[var].split(',').map(&:strip)
-        else
-          default
-        end
-      end
-
-      private
-
-      def decode_array(var)
-        var.is_a?(Array) ? var.find { |env_var| ENV.key?(env_var) } : var
-      end
-    end
-
-    extend Helpers
-  end
-end