ls-trace 0.1.2 → 0.2.0

data/lib/ddtrace/contrib/sneakers/configuration/settings.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    module Sneakers
+      module Configuration
+        # Default settings for the Shoryuken integration
+        class Settings < Datadog::Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          option :service_name, default: Ext::SERVICE_NAME
+          option :tag_body, default: false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Contrib
+    module Sneakers
+      # Sneakers integration constants
+      module Ext
+        APP = 'sneakers'.freeze
+        ENV_ENABLED = 'DD_TRACE_SNEAKERS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_SNEAKERS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_SNEAKERS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SNEAKERS_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_SNEAKERS_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'sneakers'.freeze
+        SPAN_JOB = 'sneakers.job'.freeze
+        TAG_JOB_ROUTING_KEY = 'sneakers.routing_key'.freeze
+        TAG_JOB_QUEUE = 'sneakers.queue'.freeze
+        TAG_JOB_BODY = 'sneakers.body'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sneakers/integration.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/sneakers/ext'
+require 'ddtrace/contrib/sneakers/configuration/settings'
+require 'ddtrace/contrib/sneakers/patcher'
+
+module Datadog
+  module Contrib
+    module Sneakers
+      # Description of Sneakers integration
+      class Integration
+        include Datadog::Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('2.12.0')
+
+        register_as :sneakers, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['sneakers'] && Gem.loaded_specs['sneakers'].version
+        end
+
+        def self.loaded?
+          !defined?(::Sneakers).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sneakers/patcher.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/sneakers/tracer'
+
+module Datadog
+  module Contrib
+    module Sneakers
+      # Patcher enables patching of 'sneakers' module.
+      module Patcher
+        include Datadog::Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          ::Sneakers.middleware.use(Sneakers::Tracer, nil)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sneakers/tracer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module Sneakers
+      # Tracer is a Sneakers server-side middleware which traces executed jobs
+      class Tracer
+        def initialize(app, *args)
+          @app = app
+          @args = args
+        end
+
+        def call(deserialized_msg, delivery_info, metadata, handler)
+          trace_options = {
+            service:   configuration[:service_name],
+            span_type: Datadog::Ext::AppTypes::WORKER
+          }
+          request_span = tracer.trace(Ext::SPAN_JOB, trace_options)
+
+          # Set analytics sample rate
+          if Datadog::Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Datadog::Contrib::Analytics.set_sample_rate(request_span, configuration[:analytics_sample_rate])
+          end
+
+          # Measure service stats
+          Contrib::Analytics.set_measured(request_span)
+
+          request_span.resource = @app.to_proc.binding.eval('self.class').to_s
+          request_span.set_tag(Ext::TAG_JOB_ROUTING_KEY, delivery_info.routing_key)
+          request_span.set_tag(Ext::TAG_JOB_QUEUE, delivery_info.consumer.queue.name)
+
+          if configuration[:tag_body]
+            request_span.set_tag(Ext::TAG_JOB_BODY, deserialized_msg)
+          end
+
+          @app.call(deserialized_msg, delivery_info, metadata, handler)
+        rescue StandardError => e
+          request_span.set_error(e) unless request_span.nil?
+          raise e
+        ensure
+          request_span.finish if request_span
+        end
+
+        private
+
+        def tracer
+          configuration[:tracer]
+        end
+
+        def configuration
+          Datadog.configuration[:sneakers]
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sucker_punch/configuration/settings.rb

@@ -7,13 +7,18 @@ module Datadog
       module Configuration
         # Custom settings for the SuckerPunch integration
         class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
           option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
             o.lazy
           end
 
           option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
             o.lazy
           end
 

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/contrib/sucker_punch/instrumentation.rb

@@ -11,6 +11,7 @@ module Datadog
 
         # rubocop:disable Metrics/MethodLength
         def patch!
+          # rubocop:disable Metrics/BlockLength
           ::SuckerPunch::Job::ClassMethods.class_eval do
             alias_method :__run_perform_without_datadog, :__run_perform
             def __run_perform(*args)
@@ -19,10 +20,15 @@ module Datadog
 
               __with_instrumentation(Ext::SPAN_PERFORM) do |span|
                 span.resource = "PROCESS #{self}"
+
                 # Set analytics sample rate
                 if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
                   Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
                 end
+
+                # Measure service stats
+                Contrib::Analytics.set_measured(span)
+
                 __run_perform_without_datadog(*args)
               end
             rescue => e
@@ -33,6 +39,10 @@ module Datadog
             def perform_async(*args)
               __with_instrumentation(Ext::SPAN_PERFORM_ASYNC) do |span|
                 span.resource = "ENQUEUE #{self}"
+
+                # Measure service stats
+                Contrib::Analytics.set_measured(span)
+
                 __perform_async(*args)
               end
             end
@@ -42,6 +52,10 @@ module Datadog
               __with_instrumentation(Ext::SPAN_PERFORM_IN) do |span|
                 span.resource = "ENQUEUE #{self}"
                 span.set_tag(Ext::TAG_PERFORM_IN, interval)
+
+                # Measure service stats
+                Contrib::Analytics.set_measured(span)
+
                 __perform_in(interval, *args)
               end
             end

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

@@ -9,18 +9,20 @@ module Datadog
       class Integration
         include Contrib::Integration
 
+        MINIMUM_VERSION = Gem::Version.new('2.0.0')
+
         register_as :sucker_punch, auto_patch: true
 
         def self.version
           Gem.loaded_specs['sucker_punch'] && Gem.loaded_specs['sucker_punch'].version
         end
 
-        def self.present?
-          super && defined?(::SuckerPunch)
+        def self.loaded?
+          !defined?(::SuckerPunch).nil?
         end
 
         def self.compatible?
-          super && Gem::Version.new(::SuckerPunch::VERSION) >= Gem::Version.new('2.0.0')
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration

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

@@ -11,23 +11,17 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:sucker_punch)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:sucker_punch) do
-            begin
-              require 'ddtrace/contrib/sucker_punch/exception_handler'
-              require 'ddtrace/contrib/sucker_punch/instrumentation'
+          require 'ddtrace/contrib/sucker_punch/exception_handler'
+          require 'ddtrace/contrib/sucker_punch/instrumentation'
 
-              add_pin!
-              ExceptionHandler.patch!
-              Instrumentation.patch!
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply SuckerPunch integration: #{e}")
-            end
-          end
+          add_pin!
+          ExceptionHandler.patch!
+          Instrumentation.patch!
         end
 
         def add_pin!
@@ -35,7 +29,7 @@ module Datadog
             get_option(:service_name),
             app: Ext::APP,
             app_type: Datadog::Ext::AppTypes::WORKER,
-            tracer: get_option(:tracer)
+            tracer: -> { get_option(:tracer) }
           ).onto(::SuckerPunch)
         end
 

data/lib/ddtrace/correlation.rb

@@ -1,27 +1,37 @@
+require 'ddtrace/ext/correlation'
+require 'ddtrace/environment'
+
 module Datadog
   # Contains behavior for managing correlations with tracing
   # e.g. Retrieve a correlation to the current trace for logging, etc.
   module Correlation
     # Struct representing correlation
-    Identifier = Struct.new(:trace_id, :span_id) do
+    Identifier = Struct.new(:trace_id, :span_id, :env, :service, :version) do
       def initialize(*args)
         super
         self.trace_id = trace_id || 0
         self.span_id = span_id || 0
+        self.env = env || Datadog.configuration.env
+        self.service = service || Datadog.configuration.service
+        self.version = version || Datadog.configuration.version
       end
 
       def to_s
-        "dd.trace_id=#{trace_id} dd.span_id=#{span_id}"
+        attributes = []
+        attributes << "#{Ext::Correlation::ATTR_ENV}=#{env}" unless env.nil?
+        attributes << "#{Ext::Correlation::ATTR_SERVICE}=#{service}" unless service.nil?
+        attributes << "#{Ext::Correlation::ATTR_VERSION}=#{version}" unless version.nil?
+        attributes << "#{Ext::Correlation::ATTR_TRACE_ID}=#{trace_id}"
+        attributes << "#{Ext::Correlation::ATTR_SPAN_ID}=#{span_id}"
+        attributes.join(' ')
       end
     end.freeze
 
-    NULL_IDENTIFIER = Identifier.new.freeze
-
     module_function
 
     # Produces a CorrelationIdentifier from the Context provided
     def identifier_from_context(context)
-      return NULL_IDENTIFIER if context.nil?
+      return Identifier.new.freeze if context.nil?
       Identifier.new(context.trace_id, context.span_id).freeze
     end
   end

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