ls-trace 0.1.1

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

@@ -0,0 +1,25 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/delayed_job/ext'
+
+module Datadog
+  module Contrib
+    module DelayedJob
+      module Configuration
+        # Custom settings for the DelayedJob integration
+        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 :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module DelayedJob
+      # DelayedJob integration constants
+      module Ext
+        APP = 'delayed_job'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_DELAYED_JOB_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_DELAYED_JOB_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'delayed_job'.freeze
+        SPAN_JOB = 'delayed_job'.freeze
+        TAG_ATTEMPTS = 'delayed_job.attempts'.freeze
+        TAG_ID = 'delayed_job.id'.freeze
+        TAG_PRIORITY = 'delayed_job.priority'.freeze
+        TAG_QUEUE = 'delayed_job.queue'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/delayed_job/configuration/settings'
+require 'ddtrace/contrib/delayed_job/patcher'
+
+module Datadog
+  module Contrib
+    module DelayedJob
+      # Description of DelayedJob integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :delayed_job
+
+        def self.version
+          Gem.loaded_specs['delayed_job'] && Gem.loaded_specs['delayed_job'].version
+        end
+
+        def self.present?
+          super && defined?(::Delayed)
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+
+module Datadog
+  module Contrib
+    module DelayedJob
+      # Patcher enables patching of 'delayed_job' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:delayed_job)
+        end
+
+        def patch
+          do_once(:delayed_job) do
+            begin
+              require 'ddtrace/contrib/delayed_job/plugin'
+              add_instrumentation(::Delayed::Worker)
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply DelayedJob integration: #{e}")
+            end
+          end
+        end
+
+        def add_instrumentation(klass)
+          klass.plugins << Plugin
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -0,0 +1,57 @@
+require 'delayed/plugin'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/delayed_job/ext'
+
+module Datadog
+  module Contrib
+    module DelayedJob
+      # DelayedJob plugin that instruments invoke_job hook
+      class Plugin < Delayed::Plugin
+        def self.instrument(job, &block)
+          return block.call(job) unless tracer && tracer.enabled
+
+          # When DelayedJob is used through ActiveJob, we need to parse the payload differentely
+          # to get the actual job name
+          job_name = if job.payload_object.respond_to?(:job_data)
+                       job.payload_object.job_data['job_class']
+                     else
+                       job.name
+                     end
+
+          tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name) do |span|
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+            span.set_tag(Ext::TAG_ID, job.id)
+            span.set_tag(Ext::TAG_QUEUE, job.queue) if job.queue
+            span.set_tag(Ext::TAG_PRIORITY, job.priority)
+            span.set_tag(Ext::TAG_ATTEMPTS, job.attempts)
+            span.span_type = Datadog::Ext::AppTypes::WORKER
+
+            yield job
+          end
+        end
+
+        def self.flush(worker, &block)
+          yield worker
+
+          tracer.shutdown! if tracer && tracer.enabled
+        end
+
+        def self.configuration
+          Datadog.configuration[:delayed_job]
+        end
+
+        def self.tracer
+          configuration[:tracer]
+        end
+
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job, &method(:instrument))
+          lifecycle.around(:execute, &method(:flush))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/elasticsearch/ext'
+
+module Datadog
+  module Contrib
+    module Elasticsearch
+      module Configuration
+        # Custom settings for the Elasticsearch integration
+        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 :quantize, default: {}
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # Elasticsearch integration constants
+      module Ext
+        APP = 'elasticsearch'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_ELASTICSEARCH_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ELASTICSEARCH_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'elasticsearch'.freeze
+        SPAN_QUERY = 'elasticsearch.query'.freeze
+        SPAN_TYPE_QUERY = 'elasticsearch'.freeze
+        TAG_BODY = 'elasticsearch.body'.freeze
+        TAG_METHOD = 'elasticsearch.method'.freeze
+        TAG_PARAMS = 'elasticsearch.params'.freeze
+        TAG_URL = 'elasticsearch.url'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/elasticsearch/configuration/settings'
+require 'ddtrace/contrib/elasticsearch/patcher'
+
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # Description of Elasticsearch integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :elasticsearch, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['elasticsearch-transport'] \
+            && Gem.loaded_specs['elasticsearch-transport'].version
+        end
+
+        def self.present?
+          super && defined?(::Elasticsearch::Transport)
+        end
+
+        def self.compatible?
+          super && version >= Gem::Version.new('1.0.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/elasticsearch/ext'
+
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # Patcher enables patching of 'elasticsearch' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:elasticsearch)
+        end
+
+        def patch
+          do_once(:elasticsearch) do
+            begin
+              require 'uri'
+              require 'json'
+              require 'ddtrace/pin'
+              require 'ddtrace/contrib/elasticsearch/quantize'
+
+              patch_elasticsearch_transport_client
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Elasticsearch integration: #{e}")
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
+        def patch_elasticsearch_transport_client
+          # rubocop:disable Metrics/BlockLength
+          ::Elasticsearch::Transport::Client.class_eval do
+            alias_method :initialize_without_datadog, :initialize
+            Datadog::Patcher.without_warnings do
+              remove_method :initialize
+            end
+
+            def initialize(*args, &block)
+              tracer = Datadog.configuration[:elasticsearch][:tracer]
+              service = Datadog.configuration[:elasticsearch][:service_name]
+
+              pin = Datadog::Pin.new(
+                service,
+                app: Datadog::Contrib::Elasticsearch::Ext::APP,
+                app_type: Datadog::Ext::AppTypes::DB,
+                tracer: tracer
+              )
+              pin.onto(self)
+              initialize_without_datadog(*args, &block)
+            end
+
+            alias_method :perform_request_without_datadog, :perform_request
+            remove_method :perform_request
+
+            def perform_request(*args)
+              pin = Datadog::Pin.get_from(self)
+              return perform_request_without_datadog(*args) unless pin && pin.tracer
+
+              method = args[0]
+              path = args[1]
+              params = args[2]
+              body = args[3]
+              full_url = URI.parse(path)
+
+              url = full_url.path
+              response = nil
+              pin.tracer.trace(Datadog::Contrib::Elasticsearch::Ext::SPAN_QUERY) do |span|
+                begin
+                  connection = transport.connections.first
+                  host = connection.host[:host] if connection
+                  port = connection.host[:port] if connection
+
+                  span.service = pin.service
+                  span.span_type = Datadog::Contrib::Elasticsearch::Ext::SPAN_TYPE_QUERY
+
+                  # load JSON for the following fields unless they're already strings
+                  params = JSON.generate(params) if params && !params.is_a?(String)
+                  body = JSON.generate(body) if body && !body.is_a?(String)
+
+                  # Set analytics sample rate
+                  if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+                    Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+                  end
+
+                  span.set_tag(Datadog::Contrib::Elasticsearch::Ext::TAG_METHOD, method)
+                  span.set_tag(Datadog::Contrib::Elasticsearch::Ext::TAG_URL, url)
+                  span.set_tag(Datadog::Contrib::Elasticsearch::Ext::TAG_PARAMS, params) if params
+                  if body
+                    quantize_options = datadog_configuration[:quantize]
+                    quantized_body = Datadog::Contrib::Elasticsearch::Quantize.format_body(body, quantize_options)
+                    span.set_tag(Datadog::Contrib::Elasticsearch::Ext::TAG_BODY, quantized_body)
+                  end
+                  span.set_tag(Datadog::Ext::NET::TARGET_HOST, host) if host
+                  span.set_tag(Datadog::Ext::NET::TARGET_PORT, port) if port
+
+                  quantized_url = Datadog::Contrib::Elasticsearch::Quantize.format_url(url)
+                  span.resource = "#{method} #{quantized_url}"
+                rescue StandardError => e
+                  Datadog::Tracer.log.error(e.message)
+                ensure
+                  # the call is still executed
+                  response = perform_request_without_datadog(*args)
+                  span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
+                end
+              end
+              response
+            end
+
+            def datadog_configuration
+              Datadog.configuration[:elasticsearch]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/elasticsearch/quantize.rb

@@ -0,0 +1,80 @@
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # Quantize contains ES-specific resource quantization tools.
+      module Quantize
+        PLACEHOLDER = '?'.freeze
+        ID_PLACEHOLDER = '\1?'.freeze
+        EXCLUDE_KEYS = [].freeze
+        SHOW_KEYS = [:_index, :_type, :_id].freeze
+        DEFAULT_OPTIONS = {
+          exclude: EXCLUDE_KEYS,
+          show: SHOW_KEYS,
+          placeholder: PLACEHOLDER
+        }.freeze
+
+        module_function
+
+        def format_url(url)
+          sanitize_fragment_with_id(url)
+            .gsub(/(?:[\d]+)/, PLACEHOLDER)
+        end
+
+        def format_body(body, options = {})
+          format_body!(body, options)
+        rescue StandardError
+          options[:placeholder] || PLACEHOLDER
+        end
+
+        def format_body!(body, options = {})
+          options = merge_options(DEFAULT_OPTIONS, options)
+
+          # Determine if bulk query or not, based on content
+          statements = body.end_with?("\n") ? body.split("\n") : [body]
+
+          # Parse each statement and quantize them.
+          statements.collect do |string|
+            reserialize_json(string, options[:placeholder]) do |obj|
+              Datadog::Quantization::Hash.format(obj, options)
+            end
+          end.join("\n")
+        end
+
+        def merge_options(original, additional)
+          {}.tap do |options|
+            # Show
+            # If either is :all, value becomes :all
+            options[:show] = if original[:show] == :all || additional[:show] == :all
+                               :all
+                             else
+                               (original[:show] || []).dup.concat(additional[:show] || []).uniq
+                             end
+
+            # Exclude
+            options[:exclude] = (original[:exclude] || []).dup.concat(additional[:exclude] || []).uniq
+          end
+        end
+
+        # Parses a JSON object from a string, passes its value
+        # to the block provided, and dumps its result back to JSON.
+        # If JSON parsing fails, it prints fail_value.
+        def reserialize_json(string, fail_value = PLACEHOLDER)
+          return string unless block_given?
+          begin
+            JSON.dump(yield(JSON.parse(string)))
+          rescue JSON::ParserError
+            # If it can't parse/dump, don't raise an error.
+            fail_value
+          end
+        end
+
+        # Sanitizes URL fragment by changing it to ? whenever a number is detected
+        # This is meant as simple heuristic that attempts to detect if particular fragment
+        # represents document Id. This is meant to reduce the cardinality in most frequent cases.
+        def sanitize_fragment_with_id(url)
+          url.gsub(%r{^(/?[^/]*/[^/]*/)(?:[^\?/\d]*[\d]+[^\?/]*)}, ID_PLACEHOLDER)
+        end
+      end
+    end
+  end
+end