ddtrace 0.3.1

data/gemfiles/rails3_postgres.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "test-unit"
+gem "rails", "3.2.22.5"
+gem "pg", :platform => :ruby
+gem "activerecord-jdbcpostgresql-adapter", :platform => :jruby
+
+gemspec :path => "../"

data/gemfiles/rails3_postgres_redis.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "test-unit"
+gem "rails", "3.2.22.5"
+gem "pg", :platform => :ruby
+gem "activerecord-jdbcpostgresql-adapter", :platform => :jruby
+gem "redis-rails"
+
+gemspec :path => "../"

data/gemfiles/rails4_mysql2.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.2.7.1"
+gem "mysql2", :platform => :ruby
+gem "activerecord-jdbcmysql-adapter", :platform => :jruby
+
+gemspec :path => "../"

data/gemfiles/rails4_postgres.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.2.7.1"
+gem "pg", :platform => :ruby
+gem "activerecord-jdbcpostgresql-adapter", :platform => :jruby
+
+gemspec :path => "../"

data/gemfiles/rails4_postgres_redis.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.2.7.1"
+gem "pg", :platform => :ruby
+gem "activerecord-jdbcpostgresql-adapter", :platform => :jruby
+gem "redis-rails"
+
+gemspec :path => "../"

data/gemfiles/rails5_mysql2.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.0.0.1"
+gem "mysql2", :platform => :ruby
+
+gemspec :path => "../"

data/gemfiles/rails5_postgres.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.0.0.1"
+gem "pg", :platform => :ruby
+
+gemspec :path => "../"

data/gemfiles/rails5_postgres_redis.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.0.0.1"
+gem "pg", :platform => :ruby
+gem "redis-rails"
+
+gemspec :path => "../"

data/lib/ddtrace.rb

@@ -0,0 +1,63 @@
+require 'ddtrace/monkey'
+require 'ddtrace/pin'
+require 'ddtrace/tracer'
+
+# \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
+module Datadog
+  @tracer = Datadog::Tracer.new()
+
+  # Default tracer that can be used as soon as +ddtrace+ is required:
+  #
+  #   require 'ddtrace'
+  #
+  #   span = Datadog.tracer.trace('web.request')
+  #   span.finish()
+  #
+  # If you want to override the default tracer, the recommended way
+  # is to "pin" your own tracer onto your traced component:
+  #
+  #   tracer = Datadog::Tracer.new
+  #   pin = Datadog::Pin.get_from(mypatchcomponent)
+  #   pin.tracer = tracer
+
+  def self.tracer
+    @tracer
+  end
+end
+
+# Datadog auto instrumentation for frameworks
+if defined?(Rails::VERSION)
+  if Rails::VERSION::MAJOR.to_i >= 3
+    begin
+      # We include 'redis-rails' here if it's available, doing it later
+      # (typically in initialize callback) does not work, it does not
+      # get loaded in the right context.
+      require 'redis-rails'
+      Datadog::Tracer.log.info("'redis-rails' module found, datadog redis integration is available")
+    rescue LoadError
+      Datadog::Tracer.log.info("no 'redis-rails' module found, datadog redis integration is not available")
+    end
+    require 'ddtrace/contrib/rails/framework'
+
+    Datadog::Monkey.patch_module(:redis) # does nothing if redis is not loaded
+    Datadog::RailsPatcher.patch_renderer()
+    Datadog::RailsPatcher.patch_cache_store()
+
+    module Datadog
+      # Run the auto instrumentation directly after the initialization of the application and
+      # after the application initializers in config/initializers are run
+      class Railtie < Rails::Railtie
+        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()
+        end
+      end
+    end
+  else
+    logger = Logger.new(STDOUT)
+    logger.warn 'Detected a Rails version < 3.x.'\
+        'This version is not supported yet and the'\
+        'auto-instrumentation for core components will be disabled.'
+  end
+end

data/lib/ddtrace/buffer.rb

@@ -0,0 +1,77 @@
+require 'thread'
+
+module Datadog
+  # Buffer used to store active spans
+  class SpanBuffer
+    # ensure that a new SpanBuffer clears the thread spans
+    def initialize
+      Thread.current[:datadog_span] = nil
+    end
+
+    # Set the current active span.
+    def set(span)
+      Thread.current[:datadog_span] = span
+    end
+
+    # Return the current active span or nil.
+    def get
+      Thread.current[:datadog_span]
+    end
+
+    # Pop the current active span.
+    def pop
+      span = get()
+      set(nil)
+      span
+    end
+  end
+
+  # Trace buffer that stores application traces. The buffer has a maximum size and when
+  # the buffer is full, a random trace is discarded. This class is thread-safe and is used
+  # automatically by the ``Tracer`` instance when a ``Span`` is finished.
+  class TraceBuffer
+    def initialize(max_size)
+      @max_size = max_size
+
+      @mutex = Mutex.new()
+      @traces = []
+    end
+
+    # Add a new ``trace`` in the local queue. This method doesn't block the execution
+    # even if the buffer is full. In that case, a random trace is discarded.
+    def push(trace)
+      @mutex.synchronize do
+        len = @traces.length
+        if len < @max_size || @max_size <= 0
+          @traces << trace
+        else
+          # we should replace a random trace with the new one
+          @traces[rand(len)] = trace
+        end
+      end
+    end
+
+    # Return the current number of stored traces.
+    def length
+      @mutex.synchronize do
+        return @traces.length
+      end
+    end
+
+    # Return if the buffer is empty.
+    def empty?
+      @mutex.synchronize do
+        return @traces.empty?
+      end
+    end
+
+    # Stored traces are returned and the local buffer is reset
+    def pop
+      @mutex.synchronize do
+        traces = @traces
+        @traces = []
+        return traces
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'uri'
+require 'ddtrace/pin'
+require 'ddtrace/ext/app_types'
+require 'json'
+require 'ddtrace/contrib/elasticsearch/quantize'
+
+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
+
+      # Datadog APM Elastic Search integration.
+      module TracedClient
+        def initialize(*args)
+          pin = Datadog::Pin.new(SERVICE, app: 'elasticsearch', app_type: Datadog::Ext::AppTypes::DB)
+          pin.onto(self)
+          super(*args)
+        end
+
+        def perform_request(*args)
+          pin = Datadog::Pin.get_from(self)
+          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|
+            span.service = pin.service
+            span.span_type = SPAN_TYPE
+
+            span.set_tag(METHOD, method)
+            span.set_tag(URL, url)
+            span.set_tag(PARAMS, JSON.generate(params)) if params
+            span.set_tag(BODY, JSON.generate(body)) if body
+
+            quantized_url = Datadog::Contrib::Elasticsearch::Quantize.format_url(url)
+            span.resource = "#{method} #{quantized_url}"
+
+            response = super(*args)
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# requirements should be kept minimal as Patcher is a shared requirement.
+
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # 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 'ddtrace/contrib/elasticsearch/core'
+              ::Elasticsearch::Transport::Client.prepend Datadog::Contrib::Elasticsearch::TracedClient
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Elastic Search integration: #{e}")
+            end
+          end
+          @patched
+        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/rails/action_controller.rb

@@ -0,0 +1,75 @@
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/errors'
+
+module Datadog
+  module Contrib
+    module Rails
+      # TODO[manu]: write docs
+      module ActionController
+        KEY = 'datadog_actioncontroller'.freeze
+
+        def self.instrument
+          # subscribe when the request processing starts
+          ::ActiveSupport::Notifications.subscribe('start_processing.action_controller') do |*args|
+            start_processing(*args)
+          end
+
+          # subscribe when the request processing has been completed
+          ::ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
+            process_action(*args)
+          end
+        end
+
+        def self.start_processing(*)
+          return if Thread.current[KEY]
+
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          service = ::Rails.configuration.datadog_trace.fetch(:default_service)
+          type = Datadog::Ext::HTTP::TYPE
+          tracer.trace('rails.request', service: service, span_type: type)
+
+          Thread.current[KEY] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.process_action(_name, start, finish, _id, payload)
+          return unless Thread.current[KEY]
+          Thread.current[KEY] = false
+
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
+            span.set_tag(Datadog::Ext::HTTP::URL, payload.fetch(:path))
+            span.set_tag(Datadog::Ext::HTTP::METHOD, payload.fetch(:method))
+            span.set_tag('rails.route.action', payload.fetch(:action))
+            span.set_tag('rails.route.controller', payload.fetch(:controller))
+
+            if payload[:exception].nil?
+              # [christian] in some cases :status is not defined,
+              # rather than firing an error, simply acknowledge we don't know it.
+              span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, payload.fetch(:status, '?').to_s)
+            else
+              error = payload[:exception]
+              # TODO[manu]: it's right to have a 500? there are cases in Rails that let
+              # user to recover the error after this point?
+              span.status = 1
+              span.set_tag(Datadog::Ext::Errors::TYPE, error[0])
+              span.set_tag(Datadog::Ext::Errors::MSG, error[1])
+              span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, '500')
+            end
+
+          ensure
+            span.start_time = start
+            span.finish_at(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    module Rails
+      # TODO[manu]: write docs
+      module ActionView
+        def self.instrument
+          # subscribe when the template rendering starts
+          ::ActiveSupport::Notifications.subscribe('start_render_template.action_view') do |*args|
+            start_render_template(*args)
+          end
+
+          # subscribe when the partial rendering starts
+          ::ActiveSupport::Notifications.subscribe('start_render_partial.action_view') do |*args|
+            start_render_partial(*args)
+          end
+
+          # subscribe when the template rendering has been processed
+          ::ActiveSupport::Notifications.subscribe('render_template.action_view') do |*args|
+            render_template(*args)
+          end
+
+          # subscribe when the partial rendering has been processed
+          ::ActiveSupport::Notifications.subscribe('render_partial.action_view') do |*args|
+            render_partial(*args)
+          end
+        end
+
+        def self.get_key(f)
+          'datadog_actionview_' + f
+        end
+
+        def self.start_render_template(*)
+          key = get_key('render_template')
+          return if Thread.current[key]
+
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          type = Datadog::Ext::HTTP::TEMPLATE
+          tracer.trace('rails.render_template', span_type: type)
+
+          Thread.current[key] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.start_render_partial(*)
+          key = get_key('render_partial')
+          return if Thread.current[key]
+
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          type = Datadog::Ext::HTTP::TEMPLATE
+          tracer.trace('rails.render_partial', span_type: type)
+
+          Thread.current[key] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.render_template(_name, start, finish, _id, payload)
+          key = get_key('render_template')
+          return unless Thread.current[key]
+          Thread.current[key] = false
+
+          # finish the tracing and update the execution time
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(payload.fetch(:identifier))
+            span.set_tag('rails.template_name', template_name)
+            span.set_tag('rails.layout', payload.fetch(:layout))
+
+            if payload[:exception]
+              error = payload[:exception]
+              span.status = 1
+              span.set_tag(Datadog::Ext::Errors::TYPE, error[0])
+              span.set_tag(Datadog::Ext::Errors::MSG, error[1])
+            end
+
+          ensure
+            span.start_time = start
+            span.finish_at(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.render_partial(_name, start, finish, _id, payload)
+          key = get_key('render_partial')
+          return unless Thread.current[key]
+          Thread.current[key] = false
+
+          # finish the tracing and update the execution time
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(payload.fetch(:identifier))
+            span.set_tag('rails.template_name', template_name)
+
+            if payload[:exception]
+              error = payload[:exception]
+              span.status = 1
+              span.set_tag(Datadog::Ext::Errors::TYPE, error[0])
+              span.set_tag(Datadog::Ext::Errors::MSG, error[1])
+            end
+
+          ensure
+            span.start_time = start
+            span.finish_at(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+      end
+    end
+  end
+end