ddtrace 0.37.0 → 0.42.0

data/lib/ddtrace/contrib/sucker_punch/ext.rb

@@ -4,8 +4,11 @@ module Datadog
       # SuckerPunch integration constants
       module Ext
         APP = 'sucker_punch'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_SUCKER_PUNCH_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_SUCKER_PUNCH_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_SUCKER_PUNCH_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_SUCKER_PUNCH_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_SUCKER_PUNCH_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SUCKER_PUNCH_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_SUCKER_PUNCH_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'sucker_punch'.freeze
         SPAN_PERFORM = 'sucker_punch.perform'.freeze
         SPAN_PERFORM_ASYNC = 'sucker_punch.perform_async'.freeze

data/lib/ddtrace/diagnostics/environment_logger.rb

@@ -0,0 +1,278 @@
+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.
+    #
+    # rubocop:disable Style/DoubleNegation
+    module EnvironmentLogger
+      class << self
+        # Outputs environment information to {Datadog.logger}.
+        # Executes only for the lifetime of the program.
+        def log!(transport_responses)
+          return if @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/environment.rb

@@ -6,20 +6,34 @@ module Datadog
     # Defines helper methods for environment
     module Helpers
       def env_to_bool(var, default = nil)
-        ENV.key?(var) ? ENV[var].to_s.downcase == 'true' : default
+        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)
-        ENV.key?(var) ? ENV[var].to_f : default
+        var = decode_array(var)
+        var && ENV.key?(var) ? ENV[var].to_f : default
       end
 
       def env_to_list(var, default = [])
-        if ENV.key?(var)
+        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

data/lib/ddtrace/ext/diagnostics.rb

@@ -1,6 +1,9 @@
 module Datadog
   module Ext
     module Diagnostics
+      DD_TRACE_STARTUP_LOGS = 'DD_TRACE_STARTUP_LOGS'.freeze
+      DD_TRACE_DEBUG = 'DD_TRACE_DEBUG'.freeze
+      DD_TRACE_ENABLED = 'DD_TRACE_ENABLED'.freeze
       # Health
       module Health
         # Metrics

data/lib/ddtrace/ext/environment.rb

@@ -1,8 +1,10 @@
 module Datadog
   module Ext
     module Environment
+      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
 

data/lib/ddtrace/ext/integration.rb

@@ -0,0 +1,8 @@
+module Datadog
+  module Ext
+    module Integration
+      # Name of external service that performed the work
+      TAG_PEER_SERVICE = 'peer.service'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/runtime.rb

@@ -7,6 +7,7 @@ module Datadog
       LANG = 'ruby'.freeze
       LANG_INTERPRETER = (RUBY_ENGINE + '-' + RUBY_PLATFORM).freeze
       LANG_VERSION = RUBY_VERSION
+      RUBY_ENGINE =  ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
       TRACER_VERSION = Datadog::VERSION::STRING
 
       TAG_LANG = 'language'.freeze

data/lib/ddtrace/ext/transport.rb

@@ -6,6 +6,7 @@ module Datadog
         DEFAULT_PORT = 8126
         ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
         ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'.freeze
+        ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'.freeze
         HEADER_CONTAINER_ID = 'Datadog-Container-ID'.freeze
         HEADER_META_LANG = 'Datadog-Meta-Lang'.freeze
         HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'.freeze

data/lib/ddtrace/logger.rb

@@ -10,7 +10,7 @@ module Datadog
     def initialize(*args, &block)
       super
       self.progname = PREFIX
-      self.level = ::Logger::WARN
+      self.level = ::Logger::INFO
     end
 
     def add(severity, message = nil, progname = nil, &block)

data/lib/ddtrace/opentracer/distributed_headers.rb

@@ -44,7 +44,7 @@ module Datadog
 
       def id(header)
         value = @carrier[header].to_i
-        return if value.zero? || value >= Datadog::Span::MAX_ID
+        return if value.zero? || value >= Datadog::Span::EXTERNAL_MAX_ID
         value < 0 ? value + 0x1_0000_0000_0000_0000 : value
       end
     end

data/lib/ddtrace/pipeline/span_filter.rb

@@ -10,12 +10,22 @@ module Datadog
         @criteria = filter || block
       end
 
+      # Note: this SpanFilter implementation only handles traces in which child spans appear
+      # after parent spans in the trace array. If in the future child spans can be before
+      # parent spans, then the code below will need to be updated.
       def call(trace)
-        black_list = trace.select(&method(:drop_it?))
-
-        clean_trace(black_list, trace) while black_list.any?
-
-        trace
+        deleted = Set.new
+
+        trace.delete_if do |span|
+          if deleted.include?(span.parent)
+            deleted << span
+            true
+          else
+            drop = drop_it?(span)
+            deleted << span if drop
+            drop
+          end
+        end
       end
 
       private
@@ -23,16 +33,6 @@ module Datadog
       def drop_it?(span)
         @criteria.call(span) rescue false
       end
-
-      def clean_trace(black_list, trace)
-        current = black_list.shift
-
-        trace.delete(current)
-
-        trace.each do |span|
-          black_list << span if span.parent == current
-        end
-      end
     end
   end
 end

data/lib/ddtrace/propagation/grpc_propagator.rb

@@ -38,24 +38,36 @@ module Datadog
       end
 
       def trace_id
-        value = @metadata[GRPC_METADATA_TRACE_ID].to_i
-        value if (1..Span::MAX_ID).cover? value
+        value = metadata_for_key(GRPC_METADATA_TRACE_ID).to_i
+        value if (1..Span::EXTERNAL_MAX_ID).cover? value
       end
 
       def parent_id
-        value = @metadata[GRPC_METADATA_PARENT_ID].to_i
-        value if (1..Span::MAX_ID).cover? value
+        value = metadata_for_key(GRPC_METADATA_PARENT_ID).to_i
+        value if (1..Span::EXTERNAL_MAX_ID).cover? value
       end
 
       def sampling_priority
-        value = @metadata[GRPC_METADATA_SAMPLING_PRIORITY]
+        value = metadata_for_key(GRPC_METADATA_SAMPLING_PRIORITY)
         value && value.to_i
       end
 
       def origin
-        value = @metadata[GRPC_METADATA_ORIGIN]
+        value = metadata_for_key(GRPC_METADATA_ORIGIN)
         value if value != ''
       end
+
+      private
+
+      def metadata_for_key(key)
+        # metadata values can be arrays (multiple headers with the same key)
+        value = @metadata[key]
+        if value.is_a?(Array)
+          value.first
+        else
+          value
+        end
+      end
     end
   end
 end