fair-ddtrace 0.8.2.a

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

@@ -0,0 +1,94 @@
+module Datadog
+  module Contrib
+    module ActiveRecord
+      # Patcher enables patching of 'active_record' module.
+      # This is used in monkey.rb to manually apply patches
+      module Patcher
+        @patched = false
+
+        module_function
+
+        # patched? tells whether patch has been successfully applied
+        def patched?
+          @patched
+        end
+
+        def patch
+          if !@patched && defined?(::ActiveRecord)
+            begin
+              require 'ddtrace/contrib/rails/utils'
+              require 'ddtrace/ext/sql'
+              require 'ddtrace/ext/app_types'
+
+              patch_active_record()
+
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Active Record integration: #{e}")
+            end
+          end
+
+          @patched
+        end
+
+        def patch_active_record
+          # subscribe when the active record query has been processed
+          ::ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+            sql(*args)
+          end
+        end
+
+        def self.datadog_trace
+          # TODO: Consider using patcher for Rails as well.
+          # @tracer ||= defined?(::Rails) && ::Rails.configuration.datadog_trace
+          @datadog_trace ||= defined?(::Sinatra) && ::Sinatra::Application.settings.datadog_tracer.cfg
+        end
+
+        def self.adapter_name
+          @adapter_name ||= Datadog::Contrib::Rails::Utils.normalize_vendor(
+            ::ActiveRecord::Base.connection_config[:adapter]
+          )
+        end
+
+        def self.tracer
+          return Datadog.tracer unless datadog_trace
+          @tracer ||= datadog_trace.fetch(:tracer)
+        end
+
+        def self.database_service
+          @database_service ||= if defined?(::Sinatra)
+                                  datadog_trace.fetch(:default_database_service, adapter_name())
+                                else
+                                  adapter_name()
+                                end
+          if @database_service
+            tracer().set_service_info(@database_service, 'sinatra',
+                                      Datadog::Ext::AppTypes::DB)
+          end
+          @database_service
+        end
+
+        def self.sql(_name, start, finish, _id, payload)
+          span_type = Datadog::Ext::SQL::TYPE
+
+          span = tracer.trace(
+            "#{adapter_name}.query",
+            resource: payload.fetch(:sql),
+            service: database_service,
+            span_type: span_type
+          )
+
+          # the span should have the query ONLY in the Resource attribute,
+          # so that the ``sql.query`` tag will be set in the agent with an
+          # obfuscated version
+          span.span_type = Datadog::Ext::SQL::TYPE
+          span.set_tag('active_record.db.vendor', adapter_name)
+          span.start_time = start
+          span.finish(finish)
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# requirements should be kept minimal as Patcher is a shared requirement.
+
+module Datadog
+  module Contrib
+    module Elasticsearch
+      URL = 'elasticsearch.url'.freeze
+      METHOD = 'elasticsearch.method'.freeze
+      PARAMS = 'elasticsearch.params'.freeze
+      BODY = 'elasticsearch.body'.freeze
+
+      SERVICE = 'elasticsearch'.freeze
+      SPAN_TYPE = 'elasticsearch'.freeze
+
+      # Patcher enables patching of 'elasticsearch/transport' module.
+      # This is used in monkey.rb to automatically apply patches
+      module Patcher
+        @patched = false
+
+        module_function
+
+        # patch applies our patch if needed
+        def patch
+          if !@patched && (defined?(::Elasticsearch::Transport::VERSION) && \
+                           Gem::Version.new(::Elasticsearch::Transport::VERSION) >= Gem::Version.new('1.0.0'))
+            begin
+              require 'uri'
+              require 'json'
+              require 'ddtrace/monkey'
+              require 'ddtrace/pin'
+              require 'ddtrace/ext/app_types'
+              require 'ddtrace/contrib/elasticsearch/quantize'
+
+              patch_elasticsearch_transport_client()
+
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Elastic Search integration: #{e}")
+            end
+          end
+          @patched
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def patch_elasticsearch_transport_client
+          ::Elasticsearch::Transport::Client.class_eval do
+            alias_method :initialize_without_datadog, :initialize
+            Datadog::Monkey.without_warnings do
+              remove_method :initialize
+            end
+
+            def initialize(*args)
+              pin = Datadog::Pin.new(SERVICE, app: 'elasticsearch', app_type: Datadog::Ext::AppTypes::DB)
+              pin.onto(self)
+              initialize_without_datadog(*args)
+            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('elasticsearch.query') do |span|
+                begin
+                  span.service = pin.service
+                  span.span_type = SPAN_TYPE
+
+                  # 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)
+
+                  span.set_tag(METHOD, method)
+                  span.set_tag(URL, url)
+                  span.set_tag(PARAMS, params) if params
+                  span.set_tag(BODY, body) if body
+
+                  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('http.status_code', response.status)
+                end
+              end
+              response
+            end
+          end
+        end
+
+        # patched? tells wether patch has been successfully applied
+        def patched?
+          @patched
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # Quantize contains ES-specific resource quantization tools.
+      module Quantize
+        ID_REGEXP = %r{\/([0-9]+)([\/\?]|$)}
+        ID_PLACEHOLDER = '/?\2'.freeze
+
+        INDEX_REGEXP = /[0-9]{2,}/
+        INDEX_PLACEHOLDER = '?'.freeze
+
+        module_function
+
+        # Very basic quantization, complex processing should be done in the agent
+        def format_url(url)
+          quantized_url = url.gsub(ID_REGEXP, ID_PLACEHOLDER)
+          quantized_url.gsub(INDEX_REGEXP, INDEX_PLACEHOLDER)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/grape/endpoint.rb

@@ -0,0 +1,164 @@
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/errors'
+
+module Datadog
+  module Contrib
+    module Grape
+      # rubocop:disable Metrics/ModuleLength
+      # Endpoint module includes a list of subscribers to create
+      # traces when a Grape endpoint is hit
+      module Endpoint
+        KEY_RUN = 'datadog_grape_endpoint_run'.freeze
+        KEY_RENDER = 'datadog_grape_endpoint_render'.freeze
+
+        def self.subscribe
+          # Grape is instrumented only if it's available
+          return unless defined?(::Grape) && defined?(::ActiveSupport::Notifications)
+
+          # subscribe when a Grape endpoint is hit
+          ::ActiveSupport::Notifications.subscribe('endpoint_run.grape.start_process') do |*args|
+            endpoint_start_process(*args)
+          end
+          ::ActiveSupport::Notifications.subscribe('endpoint_run.grape') do |*args|
+            endpoint_run(*args)
+          end
+          ::ActiveSupport::Notifications.subscribe('endpoint_render.grape.start_render') do |*args|
+            endpoint_start_render(*args)
+          end
+          ::ActiveSupport::Notifications.subscribe('endpoint_render.grape') do |*args|
+            endpoint_render(*args)
+          end
+          ::ActiveSupport::Notifications.subscribe('endpoint_run_filters.grape') do |*args|
+            endpoint_run_filters(*args)
+          end
+        end
+
+        def self.endpoint_start_process(*)
+          return if Thread.current[KEY_RUN]
+
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          # store the beginning of a trace
+          tracer = pin.tracer
+          service = pin.service
+          type = Datadog::Ext::HTTP::TYPE
+          tracer.trace('grape.endpoint_run', service: service, span_type: type)
+
+          Thread.current[KEY_RUN] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.endpoint_run(name, start, finish, id, payload)
+          return unless Thread.current[KEY_RUN]
+          Thread.current[KEY_RUN] = false
+
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          tracer = pin.tracer
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            # collect endpoint details
+            api_view = payload[:endpoint].options[:for].to_s
+            path = payload[:endpoint].options[:path].join('/')
+            resource = "#{api_view}##{path}"
+            span.resource = resource
+
+            # set the request span resource if it's a `rack.request` span
+            request_span = payload[:env][:datadog_rack_request_span]
+            if !request_span.nil? && request_span.name == 'rack.request'
+              request_span.resource = resource
+            end
+
+            # catch thrown exceptions
+            span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
+
+            # override the current span with this notification values
+            span.set_tag('grape.route.endpoint', api_view)
+            span.set_tag('grape.route.path', path)
+          ensure
+            span.start_time = start
+            span.finish(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.endpoint_start_render(*)
+          return if Thread.current[KEY_RENDER]
+
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          # store the beginning of a trace
+          tracer = pin.tracer
+          service = pin.service
+          type = Datadog::Ext::HTTP::TYPE
+          tracer.trace('grape.endpoint_render', service: service, span_type: type)
+
+          Thread.current[KEY_RENDER] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.endpoint_render(name, start, finish, id, payload)
+          return unless Thread.current[KEY_RENDER]
+          Thread.current[KEY_RENDER] = false
+
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          tracer = pin.tracer
+          span = tracer.active_span()
+          return unless span
+
+          # catch thrown exceptions
+          begin
+            span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
+          ensure
+            span.start_time = start
+            span.finish(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.endpoint_run_filters(name, start, finish, id, payload)
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          # safe-guard to prevent submitting empty filters
+          zero_length = (finish - start).zero?
+          filters = payload[:filters]
+          type = payload[:type]
+          return if (!filters || filters.empty?) || !type || zero_length
+
+          tracer = pin.tracer
+          service = pin.service
+          type = Datadog::Ext::HTTP::TYPE
+          span = tracer.trace('grape.endpoint_run_filters', service: service, span_type: type)
+
+          begin
+            # catch thrown exceptions
+            span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
+            span.set_tag('grape.filter.type', type.to_s)
+          ensure
+            span.start_time = start
+            span.finish(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Datadog
+  module Contrib
+    module Grape
+      SERVICE = 'grape'.freeze
+
+      # Patcher that introduces more instrumentation for Grape endpoints, so that
+      # new signals are executed at the beginning of each step (filters, render and run)
+      module Patcher
+        @patched = false
+
+        module_function
+
+        def patched?
+          @patched
+        end
+
+        def patch
+          if !@patched && defined?(::Grape)
+            begin
+              # do not require these by default, but only when actually patching
+              require 'ddtrace'
+              require 'ddtrace/ext/app_types'
+              require 'ddtrace/contrib/grape/endpoint'
+
+              @patched = true
+              # patch all endpoints
+              patch_endpoint_run()
+              patch_endpoint_render()
+
+              # attach a PIN object globally and set the service once
+              pin = Datadog::Pin.new(SERVICE, app: 'grape', app_type: Datadog::Ext::AppTypes::WEB)
+              pin.onto(::Grape)
+              if pin.tracer && pin.service
+                pin.tracer.set_service_info(pin.service, 'grape', pin.app_type)
+              end
+
+              # subscribe to ActiveSupport events
+              Datadog::Contrib::Grape::Endpoint.subscribe()
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Grape integration: #{e}")
+            end
+          end
+          @patched
+        end
+
+        def patch_endpoint_run
+          ::Grape::Endpoint.class_eval do
+            alias_method :run_without_datadog, :run
+            def run(*args)
+              ::ActiveSupport::Notifications.instrument('endpoint_run.grape.start_process')
+              run_without_datadog(*args)
+            end
+          end
+        end
+
+        def patch_endpoint_render
+          ::Grape::Endpoint.class_eval do
+            class << self
+              alias_method :generate_api_method_without_datadog, :generate_api_method
+              def generate_api_method(*params, &block)
+                method_api = generate_api_method_without_datadog(*params, &block)
+                proc do |*args|
+                  ::ActiveSupport::Notifications.instrument('endpoint_render.grape.start_render')
+                  method_api.call(*args)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end