cw-datadog 2.23.0.2

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '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.type = Tracing::Metadata::Ext::SQL::TYPE
+                    span.set_tag(Ext::TAG_QUERY_ASYNC, false)
+                  rescue => 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.type = Tracing::Metadata::Ext::SQL::TYPE
+                    span.set_tag(Ext::TAG_QUERY_ASYNC, !blk.nil?)
+                  rescue => 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.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 => e
+                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                  end
+
+                  super(query_id)
+                end
+              end
+
+              private
+
+              def datadog_configuration
+                Datadog.configuration.tracing[: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)
+                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)
+                  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)
+
+                # 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)
+                @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,46 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative '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.gem_name
+            'presto-client'
+          end
+
+          def self.version
+            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,25 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/utils/only_once'
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Presto
+        # Patcher enables patching of 'presto-client' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def patch
+            ::Presto::Client::Client.include(Instrumentation::Client)
+          end
+        end
+      end
+    end
+  end
+end

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 = +''
+
+                @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,61 @@
+# 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'
+
+            # Database service/sql span service (i.e. the service executing the actual query)
+            #
+            # If fake services are disabled:
+            #   This value will be the same as the parent service
+            #
+            # If fake services are enabled:
+            #   This value is NOT the same as the parent service
+            #
+            # This should NOT be overridden by peer.service.
+            KEY_DATABASE_SERVICE = 'dddbs'
+
+            # The global service environment (e.g. DD_ENV)
+            KEY_ENVIRONMENT = 'dde'
+
+            # The global service name (e.g. DD_SERVICE)
+            KEY_PARENT_SERVICE = 'ddps'
+
+            # The global service version (e.g. DD_VERSION)
+            KEY_VERSION = 'ddpv'
+
+            # The hostname of the database server, as provided to the database client upon instantiation.
+            # @see Datadog::Tracing::Metadata::Ext::TAG_PEER_HOSTNAME
+            KEY_HOSTNAME = 'ddh'
+
+            # @see Datadog::Tracing::Contrib::Ext::DB::TAG_INSTANCE
+            KEY_DB_NAME = 'dddb'
+
+            # Users can use this attribute to specify the identity of the dependency/database they are connecting to.
+            # We should grab this attribute only if the user is EXPLICITLY specifying it.
+            # @see Datadog::Tracing::Metadata::Ext::TAG_PEER_SERVICE
+            KEY_PEER_SERVICE = 'ddprs'
+
+            KEY_TRACEPARENT = 'traceparent'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# 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, :append) do
+            def enabled?
+              service? || full?
+            end
+
+            def service?
+              mode == Ext::SERVICE
+            end
+
+            def full?
+              mode == Ext::FULL
+            end
+
+            def append?
+              append
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+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?
+
+            config = Datadog.configuration
+
+            parent_service = config.service
+            peer_service = span_op.get_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE)
+
+            tags = {
+              Ext::KEY_ENVIRONMENT => config.env,
+              Ext::KEY_PARENT_SERVICE => parent_service,
+              Ext::KEY_VERSION => config.version,
+              Ext::KEY_HOSTNAME => span_op.get_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME),
+              Ext::KEY_DB_NAME => span_op.get_tag(Contrib::Ext::DB::TAG_INSTANCE),
+              Ext::KEY_PEER_SERVICE => peer_service,
+            }
+
+            db_service = peer_service || span_op.service
+            if parent_service != db_service # Only set if it's different from parent_service; otherwise it's redundant
+              tags[Ext::KEY_DATABASE_SERVICE] = db_service
+            end
+
+            if mode.full?
+              # When tracing is disabled, trace_operation is a dummy object that does not contain data to build traceparent
+              if config.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
+
+            if mode.append?
+              "#{sql} #{Comment.new(tags)}"
+            else
+              "#{Comment.new(tags)} #{sql}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Que
+        module Configuration
+          # Default settings for the Que integration
+          class Settings < Contrib::Configuration::Settings
+            option :service_name
+            option :distributed_tracing, default: true, type: :bool
+
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :tag_args do |o|
+              o.type :bool
+              o.env Ext::ENV_TAG_ARGS_ENABLED
+              o.default false
+            end
+
+            option :tag_data do |o|
+              o.type :bool
+              o.env Ext::ENV_TAG_DATA_ENABLED
+              o.default false
+            end
+
+            option :on_error do |o|
+              o.type :proc, nilable: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Que
+        # Que integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_QUE_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_QUE_ANALYTICS_SAMPLE_RATE'
+          ENV_ENABLED = 'DD_TRACE_QUE_ENABLED'
+          ENV_TAG_ARGS_ENABLED = 'DD_TRACE_QUE_TAG_ARGS_ENABLED'
+          ENV_TAG_DATA_ENABLED = 'DD_TRACE_QUE_TAG_DATA_ENABLED'
+          SERVICE_NAME = 'que'
+          SPAN_JOB = 'que.job'
+          TAG_JOB_ARGS = 'que.job.args'
+          TAG_JOB_DATA = 'que.job.data'
+          TAG_JOB_ERROR_COUNT = 'que.job.error_count'
+          TAG_JOB_EXPIRED_AT = 'que.job.expired_at'
+          TAG_JOB_FINISHED_AT = 'que.job.finished_at'
+          TAG_JOB_ID = 'que.job.id'
+          TAG_JOB_PRIORITY = 'que.job.priority'
+          TAG_JOB_QUEUE = 'que.job.queue'
+          TAG_JOB_RUN_AT = 'que.job.run_at'
+          TAG_COMPONENT = 'que'
+          TAG_OPERATION_JOB = 'job'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'ext'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Que
+        # Description of Que integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('1.0.0.beta2')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :que, auto_patch: true
+
+          def self.version
+            Gem.loaded_specs['que']&.version
+          end
+
+          def self.loaded?
+            !defined?(::Que).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/que/patcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'tracer'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Que
+        # Patcher enables patching of 'que' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            ::Que.job_middleware.push(Que::Tracer.new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/que/tracer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../analytics'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Que
+        # Tracer is a Que's server-side middleware which traces executed jobs
+        class Tracer
+          def call(job)
+            trace_options = {
+              service: configuration[:service_name],
+              type: Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
+              on_error: configuration[:on_error]
+            }
+
+            Tracing.trace(Ext::SPAN_JOB, **trace_options) do |request_span|
+              request_span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+              request_span.resource = job.class.name.to_s
+
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
+
+              request_span.set_tag(Ext::TAG_JOB_QUEUE, job.que_attrs[:queue])
+              request_span.set_tag(Ext::TAG_JOB_ID, job.que_attrs[:id])
+              request_span.set_tag(Ext::TAG_JOB_PRIORITY, job.que_attrs[:priority])
+              request_span.set_tag(Ext::TAG_JOB_ERROR_COUNT, job.que_attrs[:error_count])
+              request_span.set_tag(Ext::TAG_JOB_RUN_AT, job.que_attrs[:run_at])
+              request_span.set_tag(Ext::TAG_JOB_EXPIRED_AT, job.que_attrs[:expired_at])
+              request_span.set_tag(Ext::TAG_JOB_FINISHED_AT, job.que_attrs[:finished_at])
+              request_span.set_tag(Ext::TAG_JOB_ARGS, job.que_attrs[:args]) if configuration[:tag_args]
+              request_span.set_tag(Ext::TAG_JOB_DATA, job.que_attrs[:data]) if configuration[:tag_data]
+
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
+              set_sample_rate(request_span)
+              Contrib::Analytics.set_measured(request_span)
+
+              yield
+            end
+          end
+
+          private
+
+          def set_sample_rate(request_span)
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(
+                request_span,
+                configuration[:analytics_sample_rate]
+              )
+            end
+          end
+
+          def configuration
+            Datadog.configuration.tracing[:que]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Racecar
+        module Configuration
+          # Custom settings for the Racecar integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :service_name do |o|
+              o.type :string, nilable: true
+              o.default do
+                Contrib::SpanAttributeSchema.fetch_service_name(
+                  '',
+                  Ext::DEFAULT_PEER_SERVICE_NAME
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end