ddtrace 1.4.2 → 1.19.0

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

@@ -1,9 +1,13 @@
-# typed: false
+# frozen_string_literal: true
 
 require_relative '../../metadata/ext'
 require_relative '../analytics'
+require_relative '../ext'
 require_relative 'ext'
 
+require_relative '../propagation/sql_comment'
+require_relative '../propagation/sql_comment/mode'
+
 module Datadog
   module Tracing
     module Contrib
@@ -16,97 +20,161 @@ module Datadog
 
           # PG::Connection patch methods
           module InstanceMethods
-            def exec(sql, *args)
-              trace(Ext::SPAN_EXEC, resource: sql) do
-                super(sql, *args)
+            def exec(sql, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def exec_params(sql, params, *args)
-              trace(Ext::SPAN_EXEC_PARAMS, resource: sql) do
-                super(sql, params, *args)
+            def exec_params(sql, params, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, params, *args, &wrapped_block)
               end
             end
 
-            def exec_prepared(statement_name, params, *args)
-              trace(Ext::SPAN_EXEC_PREPARED, resource: statement_name) do
-                super(statement_name, params, *args)
+            def exec_prepared(statement_name, params, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
+                super(statement_name, params, *args, &wrapped_block)
               end
             end
 
-            def async_exec(sql, *args)
-              trace(Ext::SPAN_ASYNC_EXEC, resource: sql) do
-                super(sql, *args)
+            # async_exec is an alias to exec
+            def async_exec(sql, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_ASYNC_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def async_exec_params(sql, params, *args)
-              trace(Ext::SPAN_ASYNC_EXEC_PARAMS, resource: sql) do
-                super(sql, params, *args)
+            # async_exec_params is an alias to exec_params
+            def async_exec_params(sql, params, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_ASYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, params, *args, &wrapped_block)
               end
             end
 
-            def async_exec_prepared(statement_name, params, *args)
-              trace(Ext::SPAN_ASYNC_EXEC_PREPARED, resource: statement_name) do
-                super(statement_name, params, *args)
+            # async_exec_prepared is an alias to exec_prepared
+            def async_exec_prepared(statement_name, params, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_ASYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
+                super(statement_name, params, *args, &wrapped_block)
               end
             end
 
-            def sync_exec(sql, *args)
-              trace(Ext::SPAN_SYNC_EXEC, resource: sql) do
-                super(sql, *args)
+            def sync_exec(sql, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_SYNC_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def sync_exec_params(sql, params, *args)
-              trace(Ext::SPAN_SYNC_EXEC_PARAMS, resource: sql) do
-                super(sql, params, *args)
+            def sync_exec_params(sql, params, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_SYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, params, *args, &wrapped_block)
               end
             end
 
-            def sync_exec_prepared(statement_name, params, *args)
-              trace(Ext::SPAN_SYNC_EXEC_PREPARED, resource: statement_name) do
-                super(statement_name, params, *args)
+            def sync_exec_prepared(statement_name, params, *args, &block)
+              return super unless enabled?
+
+              trace(Ext::SPAN_SYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
+                super(statement_name, params, *args, &wrapped_block)
               end
             end
 
             private
 
-            def trace(name, resource:)
+            def trace(name, sql: nil, statement_name: nil, block: nil)
               service = Datadog.configuration_for(self, :service_name) || datadog_configuration[:service_name]
-              Tracing.trace(name, service: service, resource: resource, type: Tracing::Metadata::Ext::SQL::TYPE) do |span|
+              error_handler = datadog_configuration[:error_handler]
+              resource = statement_name || sql
+
+              Tracing.trace(
+                name,
+                on_error: error_handler,
+                service: service,
+                resource: resource,
+                type: Tracing::Metadata::Ext::SQL::TYPE
+              ) do |span, trace_op|
                 annotate_span_with_query!(span, service)
                 # Set analytics sample rate
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-                result = yield
-                annotate_span_with_result!(span, result)
-                result
+
+                if sql
+                  propagation_mode = Contrib::Propagation::SqlComment::Mode.new(comment_propagation)
+                  Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)
+                  propagated_sql_statement = Contrib::Propagation::SqlComment.prepend_comment(
+                    sql,
+                    span,
+                    trace_op,
+                    propagation_mode
+                  )
+                end
+
+                # Read metadata from PG::Result
+                if block
+                  yield(propagated_sql_statement, proc do |result|
+                    ret = block.call(result)
+                    annotate_span_with_result!(span, result)
+                    ret
+                  end)
+                else
+                  result = yield(propagated_sql_statement)
+                  annotate_span_with_result!(span, result)
+                  result
+                end
               end
             end
 
             def annotate_span_with_query!(span, service)
               span.set_tag(Ext::TAG_DB_NAME, db)
 
+              if datadog_configuration[:peer_service]
+                span.set_tag(
+                  Tracing::Metadata::Ext::TAG_PEER_SERVICE,
+                  datadog_configuration[:peer_service]
+                )
+              end
+
+              # Tag original global service name if not used
+              if span.service != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
-              # Tag as an external peer service
-              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, service)
               span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, host)
 
-              span.set_tag(Tracing::Metadata::Ext::DB::TAG_INSTANCE, db)
-              span.set_tag(Tracing::Metadata::Ext::DB::TAG_USER, user)
-              span.set_tag(Tracing::Metadata::Ext::DB::TAG_SYSTEM, Ext::SPAN_SYSTEM)
+              span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, db)
+              span.set_tag(Contrib::Ext::DB::TAG_USER, user)
+              span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
 
               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::NET::TAG_DESTINATION_NAME, host)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_DESTINATION_PORT, port)
+
+              Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             end
 
+            # @param [PG::Result] result
             def annotate_span_with_result!(span, result)
-              span.set_tag(Tracing::Metadata::Ext::DB::TAG_ROW_COUNT, result.ntuples)
+              span.set_tag(Contrib::Ext::DB::TAG_ROW_COUNT, result.ntuples)
             end
 
             def datadog_configuration
@@ -120,6 +188,14 @@ module Datadog
             def analytics_sample_rate
               datadog_configuration[:analytics_sample_rate]
             end
+
+            def comment_propagation
+              datadog_configuration[:comment_propagation]
+            end
+
+            def enabled?
+              datadog_configuration[:enabled]
+            end
           end
         end
       end

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../integration'
 require_relative 'configuration/settings'
 require_relative 'patcher'

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

@@ -1,4 +1,4 @@
-# typed: ignore
+# frozen_string_literal: true
 
 require_relative '../patcher'
 require_relative 'instrumentation'

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

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 require_relative '../../configuration/settings'
 require_relative '../ext'
@@ -12,21 +12,36 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
             end
 
             option :analytics_enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
             end
 
             option :analytics_sample_rate do |o|
-              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-              o.lazy
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
             end
 
-            option :service_name, default: Ext::DEFAULT_PEER_SERVICE_NAME
+            option :service_name do |o|
+              o.default do
+                Contrib::SpanAttributeSchema.fetch_service_name(
+                  Ext::ENV_SERVICE_NAME,
+                  Ext::DEFAULT_PEER_SERVICE_NAME
+                )
+              end
+            end
+
+            option :peer_service do |o|
+              o.type :string, nilable: true
+              o.env Ext::ENV_PEER_SERVICE
+            end
           end
         end
       end

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -7,24 +7,29 @@ module Datadog
         # 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
+          ENV_ENABLED = 'DD_TRACE_PRESTO_ENABLED'
+          ENV_SERVICE_NAME = 'DD_TRACE_PRESTO_SERVICE_NAME'
+          ENV_PEER_SERVICE = 'DD_TRACE_PRESTO_PEER_SERVICE'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_PRESTO_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_PRESTO_ANALYTICS_SAMPLE_RATE'
+          DEFAULT_PEER_SERVICE_NAME = 'presto'
+          SPAN_QUERY = 'presto.query'
+          SPAN_KILL = 'presto.kill_query'
+          TAG_SCHEMA_NAME = 'presto.schema'
+          TAG_CATALOG_NAME = 'presto.catalog'
+          TAG_USER_NAME = 'presto.user'
+          TAG_TIME_ZONE = 'presto.time_zone'
+          TAG_LANGUAGE = 'presto.language'
+          TAG_PROXY = 'presto.http_proxy'
+          TAG_MODEL_VERSION = 'presto.model_version'
+          TAG_QUERY_ID = 'presto.query.id'
+          TAG_QUERY_ASYNC = 'presto.query.async'
+          TAG_COMPONENT = 'presto'
+          TAG_OPERATION_QUERY = 'query'
+          TAG_OPERATION_KILL = 'kill'
+          TAG_SYSTEM = 'presto'
+          PEER_SERVICE_SOURCES = (Array[Ext::TAG_SCHEMA_NAME] +
+                                            Contrib::Ext::DB::PEER_SERVICE_SOURCES).freeze
         end
       end
     end

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

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative '../../metadata/ext'
 require_relative 'ext'
 
@@ -81,6 +79,21 @@ module Datadog
               def decorate!(span, operation)
                 span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, operation)
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
+                span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+                if datadog_configuration[:peer_service]
+                  span.set_tag(
+                    Tracing::Metadata::Ext::TAG_PEER_SERVICE,
+                    datadog_configuration[:peer_service]
+                  )
+                end
+
+                # Tag original global service name if not used
+                if span.service != Datadog.configuration.service
+                  span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+                end
 
                 if (host_port = @options[:server])
                   host, port = Core::Utils.extract_host_port(host_port)
@@ -103,13 +116,12 @@ module Datadog
                 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
+
+                Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
               end
 
               def set_nilable_tag!(span, key, tag_name)

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../integration'
 require_relative 'configuration/settings'
 require_relative 'patcher'

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

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative '../../../core/utils/only_once'
 require_relative '../patcher'
 require_relative 'ext'

data/lib/datadog/tracing/contrib/propagation/sql_comment/comment.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Propagation
+        module SqlComment
+          # To be prepended to a sql statement.
+          class Comment
+            def initialize(hash)
+              @hash = hash
+            end
+
+            def to_s
+              @string ||= begin
+                ret = String.new
+
+                @hash.each do |key, value|
+                  next if value.nil?
+
+                  # Url encode
+                  value = ERB::Util.url_encode(value)
+
+                  # Escape SQL
+                  ret << "#{key}='#{value}',"
+                end
+
+                # Remove the last `,`
+                ret.chop!
+
+                "/*#{ret}*/"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/propagation/sql_comment/ext.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Propagation
+        module SqlComment
+          module Ext
+            ENV_DBM_PROPAGATION_MODE = 'DD_DBM_PROPAGATION_MODE'
+
+            # The default mode for sql comment propagation
+            DISABLED = 'disabled'
+
+            # The `service` mode propagates service configuration
+            SERVICE = 'service'
+
+            # The `full` mode propagates service configuration + trace context
+            FULL = 'full'
+
+            # The value should be `true` when `full` mode
+            TAG_DBM_TRACE_INJECTED = '_dd.dbm_trace_injected'
+
+            KEY_DATABASE_SERVICE = 'dddbs'
+            KEY_ENVIRONMENT = 'dde'
+            KEY_PARENT_SERVICE = 'ddps'
+            KEY_VERSION = 'ddpv'
+            KEY_TRACEPARENT = 'traceparent'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/propagation/sql_comment/mode.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Propagation
+        # Implements sql comment propagation related contracts.
+        module SqlComment
+          Mode = Struct.new(:mode) do
+            def enabled?
+              service? || full?
+            end
+
+            def service?
+              mode == Ext::SERVICE
+            end
+
+            def full?
+              mode == Ext::FULL
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/propagation/sql_comment.rb

@@ -0,0 +1,53 @@
+require_relative 'sql_comment/comment'
+require_relative 'sql_comment/ext'
+
+require_relative '../../distributed/trace_context'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Propagation
+        # Implements sql comment propagation related contracts.
+        module SqlComment
+          def self.annotate!(span_op, mode)
+            return unless mode.enabled?
+
+            span_op.set_tag(Ext::TAG_DBM_TRACE_INJECTED, true) if mode.full?
+          end
+
+          # Inject span_op and trace_op instead of TraceDigest to improve memory usage
+          # for `disabled` and `service` mode
+          def self.prepend_comment(sql, span_op, trace_op, mode)
+            return sql unless mode.enabled?
+
+            tags = {
+              Ext::KEY_DATABASE_SERVICE => span_op.get_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE) || span_op.service,
+              Ext::KEY_ENVIRONMENT => datadog_configuration.env,
+              Ext::KEY_PARENT_SERVICE => datadog_configuration.service,
+              Ext::KEY_VERSION => datadog_configuration.version
+            }
+
+            if mode.full?
+              # When tracing is disabled, trace_operation is a dummy object that does not contain data to build traceparent
+              if datadog_configuration.tracing.enabled
+                tags[Ext::KEY_TRACEPARENT] =
+                  Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_traceparent, trace_op.to_digest)
+              else
+                Datadog.logger.warn(
+                  'Sql comment propagation with `full` mode is aborted, because tracing is disabled. '\
+                  'Please set `Datadog.configuration.tracing.enabled = true` to continue.'
+                )
+              end
+            end
+
+            "#{Comment.new(tags)} #{sql}"
+          end
+
+          def self.datadog_configuration
+            Datadog.configuration
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 require_relative '../../configuration/settings'
 require_relative '../ext'
@@ -12,23 +12,27 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             option :analytics_enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
             end
 
             option :analytics_sample_rate do |o|
-              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-              o.lazy
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
             end
 
             option :tag_job_data do |o|
-              o.default { env_to_bool(Ext::ENV_TAG_JOB_DATA, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_TAG_JOB_DATA
+              o.default false
             end
 
             option :tag_job_tags do |o|
-              o.default { env_to_bool(Ext::ENV_TAG_JOB_TAGS, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_TAG_JOB_TAGS
+              o.default false
             end
 
             option :service_name

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -7,18 +7,18 @@ module Datadog
         # 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
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_QLESS_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_QLESS_ANALYTICS_SAMPLE_RATE'
+          ENV_TAG_JOB_DATA = 'DD_QLESS_TAG_JOB_DATA'
+          ENV_TAG_JOB_TAGS = 'DD_QLESS_TAG_JOB_TAGS'
+          SERVICE_NAME = 'qless'
+          SPAN_JOB = 'qless.job'
+          TAG_JOB_ID = 'qless.job.id'
+          TAG_JOB_DATA = 'qless.job.data'
+          TAG_JOB_QUEUE = 'qless.job.queue'
+          TAG_JOB_TAGS = 'qless.job.tags'
+          TAG_COMPONENT = 'qless'
+          TAG_OPERATION_JOB = 'job'
         end
       end
     end

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../integration'
 require_relative 'configuration/settings'
 require_relative 'patcher'

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative '../patcher'
 
@@ -8,7 +8,6 @@ module Datadog
       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