ls-trace 0.1.2 → 0.2.0

data/lib/ddtrace/contrib/patcher.rb

@@ -6,21 +6,55 @@ module Datadog
     module Patcher
       def self.included(base)
         base.send(:include, Datadog::Patcher)
-        base.send(:extend, InstanceMethods)
-        base.send(:include, InstanceMethods)
+
+        base.singleton_class.send(:prepend, CommonMethods)
+        base.send(:prepend, CommonMethods) if base.class == Class
       end
 
-      # Class methods for patchers
-      module ClassMethods
-        def patch
-          raise NotImplementedError, '#patch not implemented for Patcher!'
+      # Prepended instance methods for all patchers
+      module CommonMethods
+        def patch_name
+          self.class != Class && self.class != Module ? self.class.name : name
+        end
+
+        def patched?
+          done?(:patch)
         end
-      end
 
-      # Instance methods for patchers
-      module InstanceMethods
         def patch
-          raise NotImplementedError, '#patch not implemented for Patcher!'
+          return unless defined?(super)
+
+          do_once(:patch) 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: #{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
       end
     end

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

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/presto/ext'
+
+module Datadog
+  module Contrib
+    module Presto
+      module Configuration
+        # Custom settings for the Presto 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, 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Datadog
+  module Contrib
+    module Presto
+      # Presto integration constants
+      module Ext
+        APP = 'presto'.freeze
+        ENV_ENABLED = 'DD_TRACE_PRESTO_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_PRESTO_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_PRESTO_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_PRESTO_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_PRESTO_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'presto'.freeze
+        SPAN_QUERY = 'presto.query'.freeze
+        SPAN_RESUME = 'presto.resume_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
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/presto/instrumentation.rb

@@ -0,0 +1,107 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/sql'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/presto/ext'
+
+module Datadog
+  module Contrib
+    module Presto
+      # Instrumentation for Presto integration
+      module Instrumentation
+        # Instrumentation for Presto::Client::Client
+        module Client
+          def self.included(base)
+            base.send(:prepend, InstanceMethods)
+          end
+
+          # Instance methods for Presto::Client
+          module InstanceMethods
+            def run(query)
+              tracer.trace(Ext::SPAN_QUERY, span_options) do |span|
+                begin
+                  decorate!(span)
+                  span.resource = query
+                  span.span_type = Datadog::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)
+              tracer.trace(Ext::SPAN_QUERY, span_options) do |span|
+                begin
+                  decorate!(span)
+                  span.resource = query
+                  span.span_type = Datadog::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)
+              tracer.trace(Ext::SPAN_KILL, span_options) do |span|
+                begin
+                  decorate!(span)
+                  span.resource = Ext::SPAN_KILL
+                  span.span_type = Datadog::Ext::AppTypes::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 span_options
+              {
+                service: datadog_configuration[:service_name],
+                app: Ext::APP,
+                app_type: Datadog::Ext::AppTypes::DB
+              }
+            end
+
+            def tracer
+              datadog_configuration.tracer
+            end
+
+            def decorate!(span)
+              set_nilable_tag!(span, :server, Datadog::Ext::NET::TARGET_HOST)
+              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
+            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

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/presto/configuration/settings'
+require 'ddtrace/contrib/presto/patcher'
+
+module Datadog
+  module Contrib
+    module Presto
+      # Description of Presto integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('0.5.14')
+
+        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 default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/presto/ext'
+require 'ddtrace/contrib/presto/instrumentation'
+
+module Datadog
+  module Contrib
+    module Presto
+      # Patcher enables patching of 'presto-client' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:presto)
+        end
+
+        def patch
+          do_once(:presto) do
+            begin
+              ::Presto::Client::Client.send(:include, Instrumentation::Client)
+            rescue StandardError => e
+              Datadog.logger.error("Unable to apply Presto integration: #{e}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    module Que
+      module Configuration
+        # Default settings for the Que integration
+        class Settings < Datadog::Contrib::Configuration::Settings
+          option :service_name, default: Ext::SERVICE_NAME
+          option :distributed_tracing, default: true
+
+          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 :tag_args do |o|
+            o.default { env_to_bool(Ext::ENV_TAG_ARGS_ENABLED, false) }
+            o.lazy
+          end
+
+          option :tag_data do |o|
+            o.default { env_to_bool(Ext::ENV_TAG_DATA_ENABLED, false) }
+            o.lazy
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Contrib
+    module Que
+      # Que integration constants
+      module Ext
+        APP = 'que'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_QUE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_QUE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_QUE_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_QUE_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_QUE_ENABLED'.freeze
+        ENV_TAG_ARGS_ENABLED = 'DD_TRACE_QUE_TAG_ARGS_ENABLED'.freeze
+        ENV_TAG_DATA_ENABLED = 'DD_TRACE_QUE_TAG_DATA_ENABLED'.freeze
+        SERVICE_NAME = 'que'.freeze
+        SPAN_JOB = 'que.job'.freeze
+        TAG_JOB_ARGS = 'que.job.args'.freeze
+        TAG_JOB_DATA = 'que.job.data'.freeze
+        TAG_JOB_ERROR_COUNT = 'que.job.error_count'.freeze
+        TAG_JOB_EXPIRED_AT = 'que.job.expired_at'.freeze
+        TAG_JOB_FINISHED_AT = 'que.job.finished_at'.freeze
+        TAG_JOB_ID = 'que.job.id'.freeze
+        TAG_JOB_PRIORITY = 'que.job.priority'.freeze
+        TAG_JOB_QUEUE = 'que.job.queue'.freeze
+        TAG_JOB_RUN_AT = 'que.job.run_at'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/que/ext'
+require 'ddtrace/contrib/que/configuration/settings'
+require 'ddtrace/contrib/que/patcher'
+
+module Datadog
+  module Contrib
+    module Que
+      # Description of Que integration
+      class Integration
+        include Datadog::Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('1.0.0.beta2')
+
+        register_as :que, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs[Datadog::Contrib::Que::Ext::APP] &&
+            Gem.loaded_specs[Datadog::Contrib::Que::Ext::APP].version
+        end
+
+        def self.loaded?
+          !defined?(::Que).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/que/patcher.rb

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