ddtrace 0.54.2 → 1.0.0.beta1

data/lib/datadog/tracing/contrib/patchable.rb

@@ -0,0 +1,108 @@
+# typed: false
+module Datadog
+  module Tracing
+    module Contrib
+      # Base provides features that are shared across all integrations
+      module Patchable
+        def self.included(base)
+          base.extend(ClassMethods)
+          base.include(InstanceMethods)
+        end
+
+        # Class methods for integrations
+        # @public_api
+        module ClassMethods
+          # Version of the integration target code in the environment.
+          #
+          # This is the gem version, when the instrumentation target is a Ruby gem.
+          #
+          # If the target for instrumentation has concept of versioning, override {.version},
+          # otherwise override {.available?} and implement a custom target presence check.
+          # @return [Object] the target version
+          def version
+            nil
+          end
+
+          # Is the target available to be instrumented? (e.g. gem installed?)
+          #
+          # The target doesn't have to be loaded (e.g. `require`) yet, but needs to be able
+          # to be loaded before instrumentation can commence.
+          #
+          # By default, {.available?} checks if {.version} returned a non-nil object.
+          #
+          # If the target for instrumentation has concept of versioning, override {.version},
+          # otherwise override {.available?} and implement a custom target presence check.
+          # @return [Boolean] is the target available for instrumentation in this Ruby environment?
+          def available?
+            !version.nil?
+          end
+
+          # Is the target loaded into the application? (e.g. gem required? Constant defined?)
+          #
+          # The target's objects should be ready to be referenced by the instrumented when {.loaded}
+          # returns `true`.
+          #
+          # @return [Boolean] is the target ready to be referenced during instrumentation?
+          def loaded?
+            true
+          end
+
+          # Is this instrumentation compatible with the available target? (e.g. minimum version met?)
+          # @return [Boolean] is the available target compatible with this instrumentation?
+          def compatible?
+            available?
+          end
+
+          # Can the patch for this integration be applied?
+          #
+          # By default, this is equivalent to {#available?}, {#loaded?}, and {#compatible?}
+          # all being truthy.
+          def patchable?
+            available? && loaded? && compatible?
+          end
+        end
+
+        # Instance methods for integrations
+        # @public_api
+        module InstanceMethods
+          # The patcher module to inject instrumented objects into the instrumentation target.
+          #
+          # {Contrib::Patcher} includes the basic functionality of a patcher. `include`ing
+          # {Contrib::Patcher} into a new module is the recommend way to create a custom patcher.
+          #
+          # @return [Contrib::Patcher] a module that `include`s {Contrib::Patcher}
+          def patcher
+            nil
+          end
+
+          # @!visibility private
+          def patch
+            if !self.class.patchable? || patcher.nil?
+              return {
+                name: self.class.name,
+                available: self.class.available?,
+                loaded: self.class.loaded?,
+                compatible: self.class.compatible?,
+                patchable: self.class.patchable?
+              }
+            end
+
+            patcher.patch
+            true
+          end
+
+          # Can the patch for this integration be applied automatically?
+          # For example: test integrations should only be applied
+          # by the user explicitly setting `c.ci.instrument :rspec`
+          # and rails sub-modules are auto-instrumented by enabling rails
+          # so auto-instrumenting them on their own will cause changes in
+          # service naming behavior
+          # @return [Boolean] can the tracer activate this instrumentation without explicit user input?
+          def auto_instrument?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/patcher.rb

@@ -0,0 +1,73 @@
+# typed: false
+require 'datadog/core'
+require 'datadog/core/utils/only_once'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Common behavior for patcher modules.
+      #
+      # `include`ing {Contrib::Patcher} into a new module is the recommend way to create a custom patcher.
+      # The patcher can then be provided to a custom {Datadog::Tracing::Contrib::Integration} for instrumentation.
+      module Patcher
+        def self.included(base)
+          base.singleton_class.prepend(CommonMethods)
+          base.prepend(CommonMethods) if base.instance_of?(Class)
+        end
+
+        # Prepended instance methods for all patchers
+        # @public_api
+        module CommonMethods
+          def patch_name
+            self.class != Class && self.class != Module ? self.class.name : name
+          end
+
+          def patched?
+            patch_only_once.ran?
+          end
+
+          def patch
+            return unless defined?(super)
+
+            patch_only_once.run do
+              begin
+                super.tap do
+                  # Emit a metric
+                  Datadog.health_metrics.instrumentation_patched(1, tags: default_tags)
+                end
+              rescue StandardError => e
+                on_patch_error(e)
+              end
+            end
+          end
+
+          # Processes patching errors. This default implementation logs the error and reports relevant metrics.
+          # @param e [Exception]
+          def on_patch_error(e)
+            # Log the error
+            Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{Array(e.backtrace).first}")
+
+            # Emit a metric
+            tags = default_tags
+            tags << "error:#{e.class.name}"
+
+            Datadog.health_metrics.error_instrumentation_patch(1, tags: tags)
+          end
+
+          private
+
+          def default_tags
+            ["patcher:#{patch_name}"].tap do |tags|
+              tags << "target_version:#{target_version}" if respond_to?(:target_version) && !target_version.nil?
+            end
+          end
+
+          def patch_only_once
+            # NOTE: This is not thread-safe
+            @patch_only_once ||= Core::Utils::OnlyOnce.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/presto/configuration/settings.rb

@@ -0,0 +1,34 @@
+# typed: false
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/presto/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Presto
+        module Configuration
+          # Custom settings for the Presto integration
+          # @public_api
+          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.lazy
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+              o.lazy
+            end
+
+            option :service_name, default: Ext::DEFAULT_PEER_SERVICE_NAME
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/presto/ext.rb

@@ -0,0 +1,31 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Contrib
+      module Presto
+        # Presto integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_PRESTO_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_PRESTO_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_PRESTO_ANALYTICS_SAMPLE_RATE'.freeze
+          DEFAULT_PEER_SERVICE_NAME = 'presto'.freeze
+          SPAN_QUERY = 'presto.query'.freeze
+          SPAN_KILL = 'presto.kill_query'.freeze
+          TAG_SCHEMA_NAME = 'presto.schema'.freeze
+          TAG_CATALOG_NAME = 'presto.catalog'.freeze
+          TAG_USER_NAME = 'presto.user'.freeze
+          TAG_TIME_ZONE = 'presto.time_zone'.freeze
+          TAG_LANGUAGE = 'presto.language'.freeze
+          TAG_PROXY = 'presto.http_proxy'.freeze
+          TAG_MODEL_VERSION = 'presto.model_version'.freeze
+          TAG_QUERY_ID = 'presto.query.id'.freeze
+          TAG_QUERY_ASYNC = 'presto.query.async'.freeze
+          TAG_COMPONENT = 'presto'.freeze
+          TAG_OPERATION_QUERY = 'query'.freeze
+          TAG_OPERATION_KILL = 'kill'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/presto/instrumentation.rb

@@ -0,0 +1,124 @@
+# typed: true
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/presto/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Presto
+        # Instrumentation for Presto integration
+        module Instrumentation
+          # Instrumentation for Presto::Client::Client
+          module Client
+            def self.included(base)
+              base.prepend(InstanceMethods)
+            end
+
+            # Instance methods for Presto::Client
+            module InstanceMethods
+              def run(query)
+                Tracing.trace(
+                  Ext::SPAN_QUERY,
+                  service: datadog_configuration[:service_name]
+                ) do |span|
+                  begin
+                    decorate!(span, Ext::TAG_OPERATION_QUERY)
+                    span.resource = query
+                    span.span_type = Tracing::Metadata::Ext::SQL::TYPE
+                    span.set_tag(Ext::TAG_QUERY_ASYNC, false)
+                  rescue StandardError => e
+                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                  end
+
+                  super(query)
+                end
+              end
+
+              def query(query, &blk)
+                Tracing.trace(
+                  Ext::SPAN_QUERY,
+                  service: datadog_configuration[:service_name]
+                ) do |span|
+                  begin
+                    decorate!(span, Ext::TAG_OPERATION_QUERY)
+                    span.resource = query
+                    span.span_type = Tracing::Metadata::Ext::SQL::TYPE
+                    span.set_tag(Ext::TAG_QUERY_ASYNC, !blk.nil?)
+                  rescue StandardError => e
+                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                  end
+
+                  super(query, &blk)
+                end
+              end
+
+              def kill(query_id)
+                Tracing.trace(
+                  Ext::SPAN_KILL,
+                  service: datadog_configuration[:service_name]
+                ) do |span|
+                  begin
+                    decorate!(span, Ext::TAG_OPERATION_KILL)
+                    span.resource = Ext::SPAN_KILL
+                    span.span_type = Tracing::Metadata::Ext::AppTypes::TYPE_DB
+                    # ^ not an SQL type span, since there's no SQL query
+                    span.set_tag(Ext::TAG_QUERY_ID, query_id)
+                  rescue StandardError => e
+                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                  end
+
+                  super(query_id)
+                end
+              end
+
+              private
+
+              def datadog_configuration
+                Datadog.configuration[:presto]
+              end
+
+              def decorate!(span, operation)
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, operation)
+
+                if (host_port = @options[:server])
+                  host, port = Core::Utils.extract_host_port(host_port)
+                  if host && port
+                    span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, host)
+                    span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, port)
+
+                    span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, host)
+                  else
+                    span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, host_port)
+                    span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, host_port)
+                  end
+                end
+
+                set_nilable_tag!(span, :user, Ext::TAG_USER_NAME)
+                set_nilable_tag!(span, :schema, Ext::TAG_SCHEMA_NAME)
+                set_nilable_tag!(span, :catalog, Ext::TAG_CATALOG_NAME)
+                set_nilable_tag!(span, :time_zone, Ext::TAG_TIME_ZONE)
+                set_nilable_tag!(span, :language, Ext::TAG_LANGUAGE)
+                set_nilable_tag!(span, :http_proxy, Ext::TAG_PROXY)
+                set_nilable_tag!(span, :model_version, Ext::TAG_MODEL_VERSION)
+
+                # Tag as an external peer service
+                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+                end
+              end
+
+              def set_nilable_tag!(span, key, tag_name)
+                @options[key].tap { |val| span.set_tag(tag_name, val) if val }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/presto/integration.rb

@@ -0,0 +1,42 @@
+# typed: false
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/presto/configuration/settings'
+require 'datadog/tracing/contrib/presto/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Presto
+        # Description of Presto integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('0.5.14')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :presto
+
+          def self.version
+            Gem.loaded_specs['presto-client'] && Gem.loaded_specs['presto-client'].version
+          end
+
+          def self.loaded?
+            !defined?(::Presto::Client::Client).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/presto/patcher.rb

@@ -0,0 +1,36 @@
+# typed: true
+require 'datadog/core/utils/only_once'
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/presto/ext'
+require 'datadog/tracing/contrib/presto/instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Presto
+        # Patcher enables patching of 'presto-client' module.
+        module Patcher
+          include Contrib::Patcher
+
+          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
+
+          module_function
+
+          def patched?
+            PATCH_ONLY_ONCE.ran?
+          end
+
+          def patch
+            PATCH_ONLY_ONCE.run do
+              begin
+                ::Presto::Client::Client.include(Instrumentation::Client)
+              rescue StandardError => e
+                Datadog.logger.error("Unable to apply Presto integration: #{e}")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/qless/configuration/settings.rb

@@ -0,0 +1,39 @@
+# typed: false
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/qless/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Qless
+        module Configuration
+          # Custom settings for the Qless integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :analytics_enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+              o.lazy
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+              o.lazy
+            end
+
+            option :tag_job_data do |o|
+              o.default { env_to_bool(Ext::ENV_TAG_JOB_DATA, false) }
+              o.lazy
+            end
+
+            option :tag_job_tags do |o|
+              o.default { env_to_bool(Ext::ENV_TAG_JOB_TAGS, false) }
+              o.lazy
+            end
+
+            option :service_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/qless/ext.rb

@@ -0,0 +1,25 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Contrib
+      module Qless
+        # Qless integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_QLESS_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_QLESS_ANALYTICS_SAMPLE_RATE'.freeze
+          ENV_TAG_JOB_DATA = 'DD_QLESS_TAG_JOB_DATA'.freeze
+          ENV_TAG_JOB_TAGS = 'DD_QLESS_TAG_JOB_TAGS'.freeze
+          SERVICE_NAME = 'qless'.freeze
+          SPAN_JOB = 'qless.job'.freeze
+          TAG_JOB_ID = 'qless.job.id'.freeze
+          TAG_JOB_DATA = 'qless.job.data'.freeze
+          TAG_JOB_QUEUE = 'qless.job.queue'.freeze
+          TAG_JOB_TAGS = 'qless.job.tags'.freeze
+          TAG_COMPONENT = 'qless'.freeze
+          TAG_OPERATION_JOB = 'job'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/qless/integration.rb

@@ -0,0 +1,42 @@
+# typed: false
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/qless/configuration/settings'
+require 'datadog/tracing/contrib/qless/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Qless
+        # Description of Qless integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('0.10.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :qless, auto_patch: true
+
+          def self.version
+            Gem.loaded_specs['qless'] && Gem.loaded_specs['qless'].version
+          end
+
+          def self.loaded?
+            !defined?(::Qless).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/qless/patcher.rb

@@ -0,0 +1,38 @@
+# typed: true
+require 'datadog/tracing'
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/qless/integration'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Qless
+        # Patcher enables patching of 'qless' module.
+        module Patcher
+          include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'qless_job'
+            require_relative 'tracer_cleaner'
+
+            # Instrument all Qless Workers
+            # These are executed in inverse order of listing here
+            ::Qless::Workers::BaseWorker.include(QlessJob)
+            ::Qless::Workers::BaseWorker.include(TracerCleaner)
+          end
+
+          def get_option(option)
+            Datadog.configuration[:qless].get_option(option)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/qless/qless_job.rb

@@ -0,0 +1,74 @@
+# typed: false
+require 'qless'
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Qless
+        # Uses Qless job hooks to create traces
+        module QlessJob
+          def around_perform(job)
+            return super unless datadog_configuration && Tracing.enabled?
+
+            Tracing.trace(Ext::SPAN_JOB, **span_options) do |span|
+              span.resource = job.klass_name
+              span.span_type = Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+              span.set_tag(Ext::TAG_JOB_ID, job.jid)
+              span.set_tag(Ext::TAG_JOB_QUEUE, job.queue_name)
+
+              tag_job_tags = datadog_configuration[:tag_job_tags]
+              span.set_tag(Ext::TAG_JOB_TAGS, job.tags) if tag_job_tags
+
+              tag_job_data = datadog_configuration[:tag_job_data]
+              if tag_job_data && !job.data.empty?
+                job_data = job.data.with_indifferent_access
+                formatted_data = job_data.except(:tags).map do |key, value|
+                  "#{key}:#{value}".underscore
+                end
+
+                span.set_tag(Ext::TAG_JOB_DATA, formatted_data)
+              end
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
+
+              # 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)
+
+              super
+            end
+          end
+
+          def after_fork
+            configuration = Datadog.configuration[:qless]
+            return if configuration.nil?
+
+            # Add a pin, marking the job as forked.
+            # Used to trigger shutdown in forks for performance reasons.
+            # Cleanup happens in the TracerCleaner class
+            Datadog.configure_onto(::Qless, forked: true)
+          end
+
+          private
+
+          def span_options
+            { service: datadog_configuration[:service_name] }
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:qless]
+          end
+        end
+      end
+    end
+  end
+end