ddtrace 0.9.2 → 0.10.0

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

@@ -21,7 +21,7 @@ module Datadog
         # 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)
+          tracer = Datadog.configuration[:rails][:tracer]
           span = tracer.active_span()
           span.set_error(e) unless span.nil?
           raise e

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

@@ -0,0 +1,56 @@
+module Datadog
+  module Contrib
+    module Rails
+      # Patcher
+      module Patcher
+        include Base
+        register_as :rails, auto_patch: true
+
+        option :enabled, default: true
+        option :auto_instrument, default: false
+        option :auto_instrument_redis, default: false
+        option :auto_instrument_grape, default: false
+        option :default_service, default: 'rails-app'
+        option :default_controller_service, default: 'rails-controller'
+        option :default_cache_service, default: 'rails-cache'
+        option :default_grape_service, default: 'grape'
+        option :default_database_service
+        option :distributed_tracing_enabled, default: false
+        option :priority_sampling, default: false
+        option :template_base_path, default: 'views/'
+        option :tracer, default: Datadog.tracer
+        option :debug, default: false
+        option :trace_agent_hostname, default: Datadog::Writer::HOSTNAME
+        option :trace_agent_port, default: Datadog::Writer::PORT
+        option :env, default: nil
+        option :tags, default: {}
+        option :sidekiq_service, default: 'sidekiq'
+
+        @patched = false
+
+        class << self
+          def patch
+            return @patched if patched? || !compatible?
+            require_relative 'framework'
+            @patched = true
+          rescue => e
+            Datadog::Tracer.log.error("Unable to apply Rails integration: #{e}")
+            @patched
+          end
+
+          def patched?
+            @patched
+          end
+
+          def compatible?
+            return if ENV['DISABLE_DATADOG_RAILS']
+
+            defined?(::Rails::VERSION) && ::Rails::VERSION::MAJOR.to_i >= 3
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'ddtrace/contrib/rails/railtie' if Datadog.registry[:rails].compatible?

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

@@ -0,0 +1,18 @@
+require 'ddtrace/contrib/rails/framework'
+require 'ddtrace/contrib/rails/middlewares'
+require 'ddtrace/contrib/rack/middlewares'
+
+module Datadog
+  # Railtie class initializes
+  class Railtie < Rails::Railtie
+    config.app_middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
+    config.app_middleware.use(Datadog::Contrib::Rails::ExceptionMiddleware)
+
+    config.after_initialize do |app|
+      Datadog::Contrib::Rails::Framework.configure(config: app.config)
+      Datadog::Contrib::Rails::Framework.auto_instrument
+      Datadog::Contrib::Rails::Framework.auto_instrument_redis
+      Datadog::Contrib::Rails::Framework.auto_instrument_grape
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module Datadog
         def self.normalize_template_name(name)
           return if name.nil?
 
-          base_path = ::Rails.configuration.datadog_trace.fetch(:template_base_path, 'views/')
+          base_path = Datadog.configuration[:rails][:template_base_path]
           sections_view = name.split(base_path)
 
           if sections_view.length == 1

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

@@ -9,6 +9,9 @@ module Datadog
       # Patcher enables patching of 'redis' module.
       # This is used in monkey.rb to automatically apply patches
       module Patcher
+        include Base
+        register_as :redis, auto_patch: true
+
         @patched = false
 
         module_function
@@ -99,6 +102,7 @@ module Datadog
                 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)
+                span.set_metric Datadog::Ext::Redis::PIPELINE_LEN, commands.length
 
                 response = call_pipeline_without_datadog(*args, &block)
               end

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

@@ -11,7 +11,7 @@ module Datadog
         module_function
 
         def format_arg(arg)
-          str = arg.to_s
+          str = arg.is_a?(Symbol) ? arg.to_s.upcase : arg.to_s
           Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
         rescue StandardError => e
           Datadog::Tracer.log.debug("non formattable Redis arg #{str}: #{e}")

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

@@ -12,6 +12,7 @@ module Datadog
           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
+          span.set_tag Datadog::Ext::Redis::RAW_COMMAND, span.resource
         end
       end
     end

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

@@ -1,10 +1,19 @@
 module Datadog
   module Contrib
+    # Namespace for `resque` integration
     module Resque
       SERVICE = 'resque'.freeze
 
+      class << self
+        # Globally-acccesible reference for pre-forking optimization
+        attr_accessor :sync_writer
+      end
+
       # Patcher for Resque integration - sets up the pin for the integration
       module Patcher
+        include Base
+        register_as :resque, auto_patch: true
+
         @patched = false
 
         class << self

data/lib/ddtrace/contrib/resque/resque_job.rb

@@ -1,4 +1,5 @@
 require 'ddtrace/ext/app_types'
+require 'ddtrace/sync_writer'
 require 'resque'
 
 module Datadog
@@ -16,11 +17,6 @@ module Datadog
             span.service = pin.service
           end
         end
-
-        def after_perform(*args)
-          pin = Pin.get_from(::Resque)
-          pin.tracer.shutdown! if pin && pin.tracer
-        end
       end
     end
   end
@@ -30,6 +26,10 @@ Resque.before_first_fork do
   pin = Datadog::Pin.get_from(Resque)
   next unless pin && pin.tracer
   pin.tracer.set_service_info(pin.service, 'resque', Datadog::Ext::AppTypes::WORKER)
+
+  # Create SyncWriter instance before forking
+  sync_writer = Datadog::SyncWriter.new(transport: pin.tracer.writer.transport)
+  Datadog::Contrib::Resque.sync_writer = sync_writer
 end
 
 Resque.after_fork do
@@ -38,5 +38,5 @@ Resque.after_fork do
   next unless pin && pin.tracer
   # clean the state so no CoW happens
   pin.tracer.provider.context = nil
-  pin.tracer.writer.start
+  pin.tracer.writer = Datadog::Contrib::Resque.sync_writer
 end

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

@@ -14,22 +14,22 @@ 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
+        include Base
+        register_as :sidekiq
+
+        option :enabled, default: true
+        option :sidekiq_service, default: 'sidekiq'
+        option :tracer, default: Datadog.tracer
+        option :debug, default: false
+        option :trace_agent_hostname, default: Writer::HOSTNAME
+        option :trace_agent_port, default: Writer::PORT
+
         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)
+          base_config = Datadog.configuration[:sidekiq].merge(Datadog.configuration[:rails])
           user_config = base_config.merge(options)
           @tracer = user_config[:tracer]
           @sidekiq_service = user_config[:sidekiq_service]

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

@@ -17,63 +17,33 @@ 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
+      # Datadog::Contrib::Sinatra::Tracer is a Sinatra extension which traces
+      # requests.
+      module Tracer
+        include Base
+        register_as :sinatra
 
-          apply()
+        option :enabled, default: true, depends_on: [:tracer] do |value|
+          get_option(:tracer).enabled = value
         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)
+        option :service_name, default: 'sinatra', depends_on: [:tracer] do |value|
+          get_option(:tracer).set_service_info(value, 'sinatra', Ext::AppTypes::WEB)
+          value
         end
 
-        def [](key)
-          raise ArgumentError, "unknown setting '#{key}'" unless @cfg.key? key
-          @cfg[key]
-        end
+        option :tracer, default: Datadog.tracer
 
-        def []=(key, value)
-          raise ArgumentError, "unknown setting '#{key}'" unless @cfg.key? key
-          @cfg[key] = value
+        option(:debug, default: false) { |value| Tracer.debug_logging = value }
+
+        option :trace_agent_hostname, default: Writer::HOSTNAME, depends_on: [:tracer] do |value|
+          get_option(:tracer).configure(hostname: value)
         end
 
-        def enabled?
-          @cfg[:enabled] && !@cfg[:tracer].nil?
+        option :trace_agent_port, default: Writer::PORT, depends_on: [:tracer] do |value|
+          get_option(:tracer).configure(port: value)
         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.
@@ -89,11 +59,9 @@ module Datadog
         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 = Datadog.configuration[:sinatra][:tracer]
+              if tracer.enabled
                 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.
@@ -108,15 +76,8 @@ module Datadog
             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?
+            return unless Datadog.configuration[:sinatra][:tracer].enabled
 
             if instance_variable_defined? :@datadog_request_span
               if @datadog_request_span
@@ -126,10 +87,10 @@ module Datadog
               end
             end
 
-            tracer = cfg[:tracer]
+            tracer = Datadog.configuration[:sinatra][:tracer]
 
             span = tracer.trace('sinatra.request',
-                                service: cfg.cfg[:default_service],
+                                service: Datadog.configuration[:sinatra][:service_name],
                                 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)
@@ -138,8 +99,7 @@ module Datadog
           end
 
           app.after do
-            cfg = settings.datadog_tracer
-            return unless cfg.enabled?
+            return unless Datadog.configuration[:sinatra][:tracer].enabled
 
             span = @datadog_request_span
             begin

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

@@ -6,6 +6,9 @@ module Datadog
 
       # Responsible for hooking the instrumentation into `sucker_punch`
       module Patcher
+        include Base
+        register_as :sucker_punch, auto_patch: true
+
         @patched = false
 
         module_function

data/lib/ddtrace/ext/distributed.rb

@@ -5,6 +5,8 @@ module Datadog
       # These are cross-language (eg: Python, Go and other implementations should honor these)
       HTTP_HEADER_TRACE_ID = 'x-datadog-trace-id'.freeze
       HTTP_HEADER_PARENT_ID = 'x-datadog-parent-id'.freeze
+      HTTP_HEADER_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
+      SAMPLING_PRIORITY_KEY = '_sampling_priority_v1'.freeze
     end
   end
 end

data/lib/ddtrace/ext/redis.rb

@@ -6,6 +6,12 @@ module Datadog
 
       # net extension
       DB = 'out.redis_db'.freeze
+
+      # raw command
+      RAW_COMMAND = 'redis.raw_command'.freeze
+
+      # pipeline length
+      PIPELINE_LEN = 'redis.pipeline_length'.freeze
     end
   end
 end

data/lib/ddtrace/monkey.rb

@@ -3,6 +3,8 @@ require 'thread'
 # We import all patchers for every module we support, but this is fine
 # because patchers do not include any 3rd party module nor even our
 # patching code, which is required on demand, when patching.
+require 'ddtrace/contrib/base'
+require 'ddtrace/contrib/rails/patcher'
 require 'ddtrace/contrib/active_record/patcher'
 require 'ddtrace/contrib/elasticsearch/patcher'
 require 'ddtrace/contrib/faraday/patcher'
@@ -18,53 +20,32 @@ require 'ddtrace/contrib/resque/patcher'
 module Datadog
   # Monkey is used for monkey-patching 3rd party libs.
   module Monkey
-    @patched = []
-    @autopatch_modules = {
-      elasticsearch: true,
-      http: true,
-      redis: true,
-      grape: true,
-      faraday: true,
-      aws: true,
-      sucker_punch: true,
-      mongo: true,
-      dalli: true,
-      resque: true,
-      active_record: false
-    }
     # Patchers should expose 2 methods:
     # - patch, which applies our patch if needed. Should be idempotent,
     #   can be call twice but should just do nothing the second time.
     # - patched?, which returns true if the module has been succesfully
     #   patched (patching might have failed if requirements were not here)
-    @patchers = { elasticsearch: Datadog::Contrib::Elasticsearch::Patcher,
-                  http: Datadog::Contrib::HTTP::Patcher,
-                  redis: Datadog::Contrib::Redis::Patcher,
-                  grape: Datadog::Contrib::Grape::Patcher,
-                  faraday: Datadog::Contrib::Faraday::Patcher,
-                  aws: Datadog::Contrib::Aws::Patcher,
-                  sucker_punch: Datadog::Contrib::SuckerPunch::Patcher,
-                  mongo: Datadog::Contrib::MongoDB::Patcher,
-                  dalli: Datadog::Contrib::Dalli::Patcher,
-                  resque: Datadog::Contrib::Resque::Patcher,
-                  active_record: Datadog::Contrib::ActiveRecord::Patcher }
+
     @mutex = Mutex.new
+    @registry = Datadog.registry
 
     module_function
 
+    attr_accessor :registry
+
     def autopatch_modules
-      @autopatch_modules.clone
+      registry.to_h
     end
 
     def patch_all
-      patch @autopatch_modules
+      patch(autopatch_modules)
     end
 
     def patch_module(m)
       @mutex.synchronize do
-        patcher = @patchers[m]
+        patcher = registry[m]
         raise "Unsupported module #{m}" unless patcher
-        patcher.patch
+        patcher.patch if patcher.respond_to?(:patch)
       end
     end
 
@@ -75,16 +56,12 @@ module Datadog
     end
 
     def get_patched_modules
-      patched = autopatch_modules
-      @patchers.each do |k, v|
-        @mutex.synchronize do
-          if v
-            patcher = @patchers[k]
-            patched[k] = patcher.patched? if patcher
-          end
+      @mutex.synchronize do
+        registry.each_with_object({}) do |entry, patched|
+          next unless entry.klass.respond_to?(:patched?)
+          patched[entry.name] = entry.klass.patched?
         end
       end
-      patched
     end
 
     def without_warnings
@@ -98,5 +75,11 @@ module Datadog
         $VERBOSE = v
       end
     end
+
+    class << self
+      attr_accessor :registry
+    end
   end
 end
+
+Datadog::Monkey.patch_module(:rails)