fair-ddtrace 0.8.2.a

data/lib/ddtrace/contrib/rails/middlewares.rb

@@ -0,0 +1,32 @@
+require 'ddtrace/ext/http'
+
+module Datadog
+  module Contrib
+    # Rails module includes middlewares that are required for Rails to be properly instrumented.
+    module Rails
+      # This is only here to catch errors, the Rack module does something very similar, however,
+      # since it's not in the same place in the stack, when the Rack middleware is called,
+      # error is already swallowed and handled by Rails so we miss the call stack, for instance.
+      class ExceptionMiddleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+        # rubocop:disable Lint/RescueException
+        # Here we really want to catch *any* exception, not only StandardError,
+        # as we really have no clue of what is in the block,
+        # and it is user code which should be executed no matter what.
+        # It's not a problem since we re-raise it afterwards so for example a
+        # SignalException::Interrupt would still bubble up.
+        rescue Exception => e
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          span = tracer.active_span()
+          span.set_error(e) unless span.nil?
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/rails/utils.rb

@@ -0,0 +1,43 @@
+module Datadog
+  module Contrib
+    module Rails
+      # common utilities for Rails
+      module Utils
+        # in Rails the template name includes the template full path
+        # and it's better to avoid storing such information. This method
+        # returns the relative path from `views/` or the template name
+        # if a `views/` folder is not in the template full path. A wrong
+        # usage ensures that this method will not crash the tracing system.
+        def self.normalize_template_name(name)
+          return if name.nil?
+
+          base_path = ::Rails.configuration.datadog_trace.fetch(:template_base_path, 'views/')
+          sections_view = name.split(base_path)
+
+          if sections_view.length == 1
+            name.split('/')[-1]
+          else
+            sections_view[-1]
+          end
+        rescue
+          return name.to_s
+        end
+
+        # TODO: Consider moving this out of Rails.
+        # Return a canonical name for a type of database
+        def self.normalize_vendor(vendor)
+          case vendor
+          when nil
+            'defaultdb'
+          when 'sqlite3'
+            'sqlite'
+          when 'postgresql'
+            'postgres'
+          else
+            vendor
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# requirements should be kept minimal as Patcher is a shared requirement.
+
+module Datadog
+  module Contrib
+    module Redis
+      SERVICE = 'redis'.freeze
+      DRIVER = 'redis.driver'.freeze
+
+      # Patcher enables patching of 'redis' 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?(::Redis::VERSION) && \
+                           Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('3.0.0'))
+            begin
+              # do not require these by default, but only when actually patching
+              require 'ddtrace/monkey'
+              require 'ddtrace/ext/app_types'
+              require 'ddtrace/contrib/redis/tags'
+              require 'ddtrace/contrib/redis/quantize'
+
+              patch_redis()
+              patch_redis_client()
+
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Redis integration: #{e}")
+            end
+          end
+          @patched
+        end
+
+        def patch_redis
+          ::Redis.module_eval do
+            def datadog_pin=(pin)
+              # Forward the pin to client, which actually traces calls.
+              Datadog::Pin.onto(client, pin)
+            end
+
+            def datadog_pin
+              # Get the pin from client, which actually traces calls.
+              Datadog::Pin.get_from(client)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/BlockLength
+        def patch_redis_client
+          ::Redis::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: 'redis', app_type: Datadog::Ext::AppTypes::DB)
+              pin.onto(self)
+              if pin.tracer && pin.service
+                pin.tracer.set_service_info(pin.service, pin.app, pin.app_type)
+              end
+              initialize_without_datadog(*args)
+            end
+
+            alias_method :call_without_datadog, :call
+            remove_method :call
+            def call(*args, &block)
+              pin = Datadog::Pin.get_from(self)
+              return call_without_datadog(*args, &block) unless pin && pin.tracer
+
+              response = nil
+              pin.tracer.trace('redis.command') do |span|
+                span.service = pin.service
+                span.span_type = Datadog::Ext::Redis::TYPE
+                span.resource = Datadog::Contrib::Redis::Quantize.format_command_args(*args)
+                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+
+                response = call_without_datadog(*args, &block)
+              end
+
+              response
+            end
+
+            alias_method :call_pipeline_without_datadog, :call_pipeline
+            remove_method :call_pipeline
+            def call_pipeline(*args, &block)
+              pin = Datadog::Pin.get_from(self)
+              return call_pipeline_without_datadog(*args, &block) unless pin && pin.tracer
+
+              response = nil
+              pin.tracer.trace('redis.command') do |span|
+                span.service = pin.service
+                span.span_type = Datadog::Ext::Redis::TYPE
+                commands = args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+                span.resource = commands.join("\n")
+                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+
+                response = call_pipeline_without_datadog(*args, &block)
+              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/redis/quantize.rb

@@ -0,0 +1,30 @@
+module Datadog
+  module Contrib
+    module Redis
+      # Quantize contains Redis-specific resource quantization tools.
+      module Quantize
+        PLACEHOLDER = '?'.freeze
+        TOO_LONG_MARK = '...'.freeze
+        VALUE_MAX_LEN = 100
+        CMD_MAX_LEN = 1000
+
+        module_function
+
+        def format_arg(arg)
+          a = arg.to_s
+          a = a[0..(VALUE_MAX_LEN - TOO_LONG_MARK.length - 1)] + TOO_LONG_MARK if a.length > VALUE_MAX_LEN
+          a
+        rescue StandardError => e
+          Datadog::Tracer.log.debug("non formattable Redis arg #{a}: #{e}")
+          PLACEHOLDER
+        end
+
+        def format_command_args(command_args)
+          cmd = command_args.map { |x| format_arg(x) }.join(' ')
+          cmd = cmd[0..(CMD_MAX_LEN - TOO_LONG_MARK.length - 1)] + TOO_LONG_MARK if cmd.length > CMD_MAX_LEN
+          cmd
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/redis/tags.rb

@@ -0,0 +1,19 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/redis'
+
+module Datadog
+  module Contrib
+    module Redis
+      # Tags handles generic common tags assignment.
+      module Tags
+        module_function
+
+        def set_common_tags(client, span)
+          span.set_tag Datadog::Ext::NET::TARGET_HOST, client.host
+          span.set_tag Datadog::Ext::NET::TARGET_PORT, client.port
+          span.set_tag Datadog::Ext::Redis::DB, client.db
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sidekiq/tracer.rb

@@ -0,0 +1,103 @@
+require 'sidekiq/api'
+
+require 'ddtrace/ext/app_types'
+
+sidekiq_vs = Gem::Version.new(Sidekiq::VERSION)
+sidekiq_min_vs = Gem::Version.new('4.0.0')
+if sidekiq_vs < sidekiq_min_vs
+  raise "sidekiq version #{sidekiq_vs} is not supported yet " \
+        + "(supporting versions >=#{sidekiq_min_vs})"
+end
+
+Datadog::Tracer.log.debug("Activating instrumentation for Sidekiq '#{sidekiq_vs}'")
+
+module Datadog
+  module Contrib
+    module Sidekiq
+      DEFAULT_CONFIG = {
+        enabled: true,
+        sidekiq_service: 'sidekiq',
+        tracer: Datadog.tracer,
+        debug: false,
+        trace_agent_hostname: Datadog::Writer::HOSTNAME,
+        trace_agent_port: Datadog::Writer::PORT
+      }.freeze
+
+      # Middleware is a Sidekiq server-side middleware which traces executed jobs
+      class Tracer
+        def initialize(options = {})
+          # check if Rails configuration is available and use it to override
+          # Sidekiq defaults
+          rails_config = ::Rails.configuration.datadog_trace rescue {}
+          base_config = DEFAULT_CONFIG.merge(rails_config)
+          user_config = base_config.merge(options)
+          @tracer = user_config[:tracer]
+          @sidekiq_service = user_config[:sidekiq_service]
+
+          # set Tracer status
+          @tracer.enabled = user_config[:enabled]
+          Datadog::Tracer.debug_logging = user_config[:debug]
+
+          # configure the Tracer instance
+          @tracer.configure(
+            hostname: user_config[:trace_agent_hostname],
+            port: user_config[:trace_agent_port]
+          )
+        end
+
+        def call(worker, job, queue)
+          # If class is wrapping something else, the interesting resource info
+          # is the underlying, wrapped class, and not the wrapper.
+          resource = if job['wrapped']
+                       job['wrapped']
+                     else
+                       job['class']
+                     end
+
+          # configure Sidekiq service
+          service = sidekiq_service(resource_worker(resource))
+          set_service_info(service)
+
+          @tracer.trace('sidekiq.job', service: service, span_type: 'job') do |span|
+            span.resource = resource
+            span.set_tag('sidekiq.job.id', job['jid'])
+            span.set_tag('sidekiq.job.retry', job['retry'])
+            span.set_tag('sidekiq.job.queue', job['queue'])
+            span.set_tag('sidekiq.job.wrapper', job['class']) if job['wrapped']
+
+            yield
+          end
+        end
+
+        private
+
+        # rubocop:disable Lint/HandleExceptions
+        def resource_worker(resource)
+          Object.const_get(resource)
+        rescue NameError
+        end
+
+        def worker_config(worker)
+          if worker.respond_to?(:datadog_tracer_config)
+            worker.datadog_tracer_config
+          else
+            {}
+          end
+        end
+
+        def sidekiq_service(resource)
+          worker_config(resource).fetch(:service, @sidekiq_service)
+        end
+
+        def set_service_info(service)
+          return if @tracer.services[service]
+          @tracer.set_service_info(
+            service,
+            'sidekiq',
+            Datadog::Ext::AppTypes::WORKER
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sinatra/tracer.rb

@@ -0,0 +1,169 @@
+
+require 'sinatra/base'
+
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/errors'
+require 'ddtrace/ext/http'
+
+sinatra_vs = Gem::Version.new(Sinatra::VERSION)
+sinatra_min_vs = Gem::Version.new('1.4.0')
+if sinatra_vs < sinatra_min_vs
+  raise "sinatra version #{sinatra_vs} is not supported yet " \
+        + "(supporting versions >=#{sinatra_min_vs})"
+end
+
+Datadog::Tracer.log.info("activating instrumentation for sinatra #{sinatra_vs}")
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # TracerCfg is used to manipulate the configuration of the Sinatra
+      # tracing extension.
+      class TracerCfg
+        DEFAULT_CFG = {
+          enabled: true,
+          default_service: 'sinatra',
+          tracer: Datadog.tracer,
+          debug: false,
+          trace_agent_hostname: Datadog::Writer::HOSTNAME,
+          trace_agent_port: Datadog::Writer::PORT
+        }.freeze()
+
+        attr_accessor :cfg
+
+        def initialize
+          @cfg = DEFAULT_CFG.dup()
+        end
+
+        def configure(args = {})
+          args.each do |name, value|
+            self[name] = value
+          end
+
+          apply()
+        end
+
+        def apply
+          Datadog::Tracer.debug_logging = @cfg[:debug]
+
+          tracer = @cfg[:tracer]
+
+          tracer.enabled = @cfg[:enabled]
+          tracer.configure(hostname: @cfg[:trace_agent_hostname],
+                           port: @cfg[:trace_agent_port])
+
+          tracer.set_service_info(@cfg[:default_service], 'sinatra',
+                                  Datadog::Ext::AppTypes::WEB)
+        end
+
+        def [](key)
+          raise ArgumentError, "unknown setting '#{key}'" unless @cfg.key? key
+          @cfg[key]
+        end
+
+        def []=(key, value)
+          raise ArgumentError, "unknown setting '#{key}'" unless @cfg.key? key
+          @cfg[key] = value
+        end
+
+        def enabled?
+          @cfg[:enabled] && !@cfg[:tracer].nil?
+        end
+      end
+
+      # Datadog::Contrib::Sinatra::Tracer is a Sinatra extension which traces
+      # requests.
+      module Tracer
+        def route(verb, action, *)
+          # Keep track of the route name when the app is instantiated for an
+          # incoming request.
+          condition do
+            @datadog_route = action
+          end
+
+          super
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        def self.registered(app)
+          ::Sinatra::Base.module_eval do
+            def render(engine, data, *)
+              cfg = settings.datadog_tracer
+
+              output = ''
+              if cfg.enabled?
+                tracer = cfg[:tracer]
+                tracer.trace('sinatra.render_template') do |span|
+                  # If data is a string, it is a literal template and we don't
+                  # want to record it.
+                  span.set_tag('sinatra.template_name', data) if data.is_a? Symbol
+                  output = super
+                end
+              else
+                output = super
+              end
+
+              output
+            end
+          end
+
+          app.set :datadog_tracer, TracerCfg.new()
+
+          app.configure do
+            app.settings.datadog_tracer.apply()
+          end
+
+          app.before do
+            cfg = settings.datadog_tracer
+            return unless cfg.enabled?
+
+            if instance_variable_defined? :@datadog_request_span
+              if @datadog_request_span
+                Datadog::Tracer.log.error('request span active in :before hook')
+                @datadog_request_span.finish()
+                @datadog_request_span = nil
+              end
+            end
+
+            tracer = cfg[:tracer]
+
+            span = tracer.trace('sinatra.request',
+                                service: cfg.cfg[:default_service],
+                                span_type: Datadog::Ext::HTTP::TYPE)
+            span.set_tag(Datadog::Ext::HTTP::URL, request.path)
+            span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
+
+            @datadog_request_span = span
+          end
+
+          app.after do
+            cfg = settings.datadog_tracer
+            return unless cfg.enabled?
+
+            span = @datadog_request_span
+            begin
+              unless span
+                Datadog::Tracer.log.error('missing request span in :after hook')
+                return
+              end
+
+              span.resource = "#{request.request_method} #{@datadog_route}"
+              span.set_tag('sinatra.route.path', @datadog_route)
+              span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
+              span.set_error(env['sinatra.error']) if response.server_error?
+              span.finish()
+            ensure
+              @datadog_request_span = nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# rubocop:disable Style/Documentation
+module Sinatra
+  register Datadog::Contrib::Sinatra::Tracer
+end