ddtrace 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9dc26d3b7ce6a1750bd273655bfb068604249878
-  data.tar.gz: 9c431f39db93b20c1d3c854e8efa1cb3b8d030b4
+  metadata.gz: 80f9cffb7ec1f57e9215784dd53d859b6a9ffae7
+  data.tar.gz: 348d67544886fa8762b2c2125dd8033a766d5f62
 SHA512:
-  metadata.gz: 044bc1ebc2a9e74f66754fbe3514563a8f8ad735e3547bcdc7ca61e508cbd3fac52a7f16d451d719c5402f05272a5f3ea7951b57a7c155fcc27b897cae063a62
-  data.tar.gz: 29ce52bf23933396a5d45b2467d43c0a9b1642769f6119fe22c8f38b544b2c796cf309366de063498f3ad07e4026dd48d18ac03179f24952cf31d96fb5b7597c
+  metadata.gz: e6795138d773ce92ba5123d9fbbe42a84c49a66800a9ab2a487f5c73900059b5197dbae0768e055fd11b9990fed3e1c812cf5f0637c87de7f7b56fa0ec1ba242
+  data.tar.gz: 1658c85972eb0be8ecc6941382558623d2ba54407e3d28874efe5c6e0936510e108512ee6314cf8d483796a903e71af77a4b47057441d2ff25e35e3174c4dfc5

data/.rubocop.yml

@@ -34,7 +34,7 @@ Style/NumericLiterals:
   Enabled: false
 
 Metrics/ClassLength:
-  Max: 120
+  Max: 140
 
 Metrics/BlockLength:
   Max: 42
@@ -47,3 +47,6 @@ Metrics/CyclomaticComplexity:
 
 Metrics/PerceivedComplexity:
   Max: 15
+
+Lint/UnusedMethodArgument:
+    Enabled: false

data/Appraisals

@@ -40,6 +40,20 @@ if RUBY_VERSION < "2.4.0"
     gem 'activerecord-jdbcpostgresql-adapter', platform: :jruby
     gem "redis-rails"
   end
+  appraise "rails3-postgres-sidekiq" do
+    gem "test-unit"
+    gem "rails", "3.2.22.5"
+    gem "pg", platform: :ruby
+    gem 'activerecord-jdbcpostgresql-adapter', platform: :jruby
+    gem "sidekiq"
+  end
+
+  appraise "rails4-postgres-sidekiq" do
+    gem "rails", "4.2.7.1"
+    gem "pg", platform: :ruby
+    gem 'activerecord-jdbcpostgresql-adapter', platform: :jruby
+    gem "sidekiq"
+  end
 
   if RUBY_VERSION >= "2.2.2" && RUBY_PLATFORM != "java"
     appraise "rails5-postgres" do
@@ -57,6 +71,12 @@ if RUBY_VERSION < "2.4.0"
       gem "pg", platform: :ruby
       gem "redis-rails"
     end
+
+    appraise "rails5-postgres-sidekiq" do
+      gem "rails", "5.0.1"
+      gem "pg", platform: :ruby
+      gem "sidekiq"
+    end
   end
 end
 
@@ -66,4 +86,5 @@ appraise "contrib" do
   gem "hiredis"
   gem "rack-test"
   gem "sinatra"
+  gem "sidekiq"
 end

data/Rakefile

@@ -6,7 +6,7 @@ require 'appraisal'
 require 'yard'
 
 namespace :test do
-  task all: [:main, :rails, :railsredis, :elasticsearch, :http, :redis, :sinatra, :monkey]
+  task all: [:main, :rails, :railsredis, :elasticsearch, :http, :redis, :sidekiq, :sinatra, :monkey]
 
   Rake::TestTask.new(:main) do |t|
     t.libs << %w(test lib)
@@ -21,7 +21,8 @@ namespace :test do
   Rake::TestTask.new(:rails) do |t|
     t.libs << %w(test lib)
     t.test_files = FileList['test/contrib/rails/**/*_test.rb'].reject do |path|
-      path.include?('redis')
+      path.include?('redis') ||
+        path.include?('sidekiq')
     end
   end
 
@@ -30,7 +31,12 @@ namespace :test do
     t.test_files = FileList['test/contrib/rails/**/*redis*_test.rb']
   end
 
-  [:elasticsearch, :http, :redis, :sinatra].each do |contrib|
+  Rake::TestTask.new(:railssidekiq) do |t|
+    t.libs << %w(test lib)
+    t.test_files = FileList['test/contrib/rails/**/*sidekiq*_test.rb']
+  end
+
+  [:elasticsearch, :http, :redis, :sinatra, :sidekiq].each do |contrib|
     Rake::TestTask.new(contrib) do |t|
       t.libs << %w(test lib)
       t.test_files = FileList["test/contrib/#{contrib}/*_test.rb"]
@@ -49,6 +55,7 @@ Rake::TestTask.new(:benchmark) do |t|
 end
 
 RuboCop::RakeTask.new(:rubocop) do |t|
+  t.options << ['-D']
   t.patterns = ['lib/**/*.rb', 'test/**/*.rb', 'Gemfile', 'Rakefile']
 end
 
@@ -114,6 +121,10 @@ task :ci do
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:http'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:redis'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:sinatra'
+    sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:sidekiq'
+    sh 'rvm $RAILS_VERSIONS --verbose do appraisal rails3-postgres-sidekiq rake test:railssidekiq'
+    sh 'rvm $RAILS_VERSIONS --verbose do appraisal rails4-postgres-sidekiq rake test:railssidekiq'
+    sh 'rvm $RAILS5_VERSIONS --verbose do appraisal rails5-postgres-sidekiq rake test:railssidekiq'
   when 2
     sh 'rvm $RAILS_VERSIONS --verbose do appraisal rails3-postgres rake test:rails'
     sh 'rvm $RAILS_VERSIONS --verbose do appraisal rails3-mysql2 rake test:rails'

data/circle.yml

@@ -28,8 +28,6 @@ dependencies:
     # configure Ruby interpreters
     - rvm get head
     - rvm install $MRI_VERSIONS
-    # run the agent
-    - docker run -d -e DD_API_KEY=invalid_key_but_this_is_fine -e DD_BIND_HOST=0.0.0.0 -e DD_APM_ENABLED=true -p 127.0.0.1:8126:8126 -p 127.0.0.1:7777:7777 datadog/docker-dd-agent
   override:
     - rvm $MRI_VERSIONS --verbose do gem update --system
     - rvm $MRI_VERSIONS --verbose do gem install bundler

data/docker-compose.yml

@@ -31,3 +31,12 @@ redis:
     image: redis:3.0
     ports:
         - "127.0.0.1:${TEST_REDIS_PORT}:6379"
+
+ddagent:
+    image: datadog/docker-dd-agent
+    environment:
+        - DD_APM_ENABLED=true
+        - DD_BIND_HOST=0.0.0.0
+        - DD_API_KEY=invalid_key_but_this_is_fine
+    ports:
+        - "127.0.0.1:8126:8126"

data/docs/GettingStarted.md

@@ -64,7 +64,7 @@ of the Datadog tracer, you can override the following defaults:
       tracer: Datadog.tracer,
       debug: false,
       trace_agent_hostname: 'localhost',
-      trace_agent_port: 7777
+      trace_agent_port: 8126
     }
 
 Available settings are:
@@ -175,6 +175,59 @@ Net::HTTP module.
 
     content = Net::HTTP.get(URI('http://127.0.0.1/index.html'))
 
+### Sidekiq
+
+The Sidekiq integration is a server-side middleware which will trace job
+executions. It can be added as any other Sidekiq middleware:
+
+    require 'sidekiq'
+    require 'ddtrace'
+    require 'ddtrace/contrib/sidekiq/tracer'
+
+    Sidekiq.configure_server do |config|
+      config.server_middleware do |chain|
+        chain.add(Datadog::Contrib::Sidekiq::Tracer)
+      end
+    end
+
+#### Configure the tracer middleware
+
+To modify the default configuration, simply pass arguments to the middleware.
+For example, to change the default service name:
+
+    Sidekiq.configure_server do |config|
+      config.server_middleware do |chain|
+        chain.add(
+          Datadog::Contrib::Sidekiq::Tracer,
+          sidekiq_service: 'sidekiq-notifications'
+        )
+      end
+    end
+
+Available settings are:
+
+* ``enabled``: define if the ``tracer`` is enabled or not. If set to
+  ``false``, the code is still instrumented but no spans are sent to the local
+  trace agent.
+* ``sidekiq_service``: set the service name used when tracing application
+  requests. Defaults to ``sidekiq``.
+* ``tracer``: set the tracer to use. Usually you don't need to change that
+  value unless you're already using a different initialized tracer somewhere
+  else.
+* ``debug``: set to ``true`` to enable debug logging.
+* ``trace_agent_hostname``: set the hostname of the trace agent.
+* ``trace_agent_port``: set the port the trace agent is listening on.
+
+If you're using Sidekiq along with [Ruby on Rails](#label-Ruby+on+Rails) auto-instrumentation,
+the Sidekiq middleware will re-use the Rails configuration defined in the initializer file before
+giving precedence to the middleware settings. Inherited configurations are:
+
+* ``enabled``
+* ``tracer``
+* ``debug``
+* ``trace_agent_hostname``
+* ``trace_agent_port``
+
 ## Advanced usage
 
 ### Manual Instrumentation
@@ -195,13 +248,16 @@ to trace requests to the home page:
         # set some span metadata
         span.service = 'my-web-site'
         span.resource = '/'
-        span.set_tag('http.method', request.request_method)
 
         # trace the activerecord call
         tracer.trace('posts.fetch') do
           @posts = Posts.order(created_at: :desc).limit(10)
         end
 
+        # add some attributes and metrics
+        span.set_tag('http.method', request.request_method)
+        span.set_metric('posts.count', len(@posts))
+
         # trace the template rendering
         tracer.trace('template.render') do
           erb :index
@@ -329,6 +385,18 @@ for the first time:
 Remember that the debug mode may affect your application performance and so it must not be used
 in a production environment.
 
+### Sampling
+
+`ddtrace` can perform trace sampling. While the trace agent already samples
+traces to reduce bandwidth usage, client sampling reduces performance
+overhead.
+
+`Datadog::RateSampler` samples a ratio of the traces. For example:
+
+    # Sample rate is between 0 (nothing sampled) to 1 (everything sampled).
+    sampler = Datadog::RateSampler.new(0.5) # sample 50% of the traces
+    Datadog.tracer.configure(sampler: sampler)
+
 ### Supported Versions
 
 #### Ruby interpreters
@@ -360,6 +428,10 @@ The currently supported web server are:
 
 Currently we are supporting Sinatra >= 1.4.0.
 
+#### Sidekiq versions
+
+Currently we are supporting Sidekiq >= 4.0.0.
+
 ### Glossary
 
 * ``Service``: The name of a set of processes that do the same job. Some examples are ``datadog-web-app`` or ``datadog-metrics-db``.

data/gemfiles/contrib.gemfile

@@ -7,5 +7,6 @@ gem "redis"
 gem "hiredis"
 gem "rack-test"
 gem "sinatra"
+gem "sidekiq"
 
 gemspec :path => "../"

data/gemfiles/rails3_postgres_sidekiq.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 "sidekiq"
+
+gemspec :path => "../"

data/gemfiles/rails4_postgres_sidekiq.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 "sidekiq"
+
+gemspec :path => "../"

data/gemfiles/rails5_postgres_sidekiq.gemfile

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

data/lib/ddtrace.rb

@@ -31,24 +31,9 @@ if defined?(Rails::VERSION)
     require 'ddtrace/contrib/rails/framework'
 
     module Datadog
-      # Run the auto instrumentation directly after the initialization of the application and
-      # after the application initializers in config/initializers are run
+      # Run the auto instrumentation directly after initializers in
+      # `config/initializers` are executed
       class Railtie < Rails::Railtie
-        config.before_configuration do
-          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.debug("'redis-rails' module found, Datadog 'redis-rails' integration is available")
-          rescue LoadError
-            Datadog::Tracer.log.debug("'redis-rails' module not found, Datadog 'redis-rails' integration is disabled")
-          end
-
-          Datadog::Monkey.patch_module(:redis)
-        end
-
-        # we do actions
         config.after_initialize do |app|
           Datadog::Contrib::Rails::Framework.configure(config: app.config)
           Datadog::Contrib::Rails::Framework.auto_instrument()

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

@@ -80,21 +80,32 @@ module Datadog
         end
 
         def self.auto_instrument_redis
-          # configure Redis PIN
-          return unless (defined? ::Rails.cache) && ::Rails.cache.respond_to?(:data)
-          pin = Datadog::Pin.get_from(::Rails.cache.data)
-          return unless pin
+          return unless ::Rails.configuration.datadog_trace[:auto_instrument_redis]
+          Datadog::Tracer.log.debug('Enabling auto-instrumentation for Redis client')
 
-          # enable Redis instrumentation if activated
-          pin.tracer = nil unless ::Rails.configuration.datadog_trace[:auto_instrument_redis]
-          return unless pin.tracer
-          Datadog::Tracer.log.debug("'redis' module found, Datadog 'redis' integration is available")
+          # patch the Redis library and reload the CacheStore if it was using Redis
+          Datadog::Monkey.patch_module(:redis)
+
+          # reload the cache store if it's available and it's using Redis
+          return unless defined?(::ActiveSupport::Cache::RedisStore) &&
+                        defined?(::Rails.cache) &&
+                        ::Rails.cache.is_a?(::ActiveSupport::Cache::RedisStore)
+          Datadog::Tracer.log.debug('Enabling auto-instrumentation for redis-rails connector')
+
+          # backward compatibility: Rails 3.x doesn't have `cache=` method
+          cache_store = ::Rails.configuration.cache_store
+          cache_instance = ::ActiveSupport::Cache.lookup_store(cache_store)
+          if ::Rails::VERSION::MAJOR.to_i == 3
+            silence_warnings { Object.const_set 'RAILS_CACHE', cache_instance }
+          elsif ::Rails::VERSION::MAJOR.to_i > 3
+            ::Rails.cache = cache_instance
+          end
         end
 
         # automatically instrument all Rails component
         def self.auto_instrument
           return unless ::Rails.configuration.datadog_trace[:auto_instrument]
-          Datadog::Tracer.log.info('Detected Rails >= 3.x. Enabling auto-instrumentation for core components')
+          Datadog::Tracer.log.debug('Enabling auto-instrumentation for core components')
 
           # instrumenting Rails framework
           Datadog::Contrib::Rails::ActionController.instrument()

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

@@ -0,0 +1,67 @@
+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]
+          )
+
+          # configure Sidekiq service
+          @tracer.set_service_info(
+            @sidekiq_service,
+            'sidekiq',
+            Datadog::Ext::AppTypes::WORKER
+          )
+        end
+
+        def call(worker, job, queue)
+          @tracer.trace('sidekiq.job', service: @sidekiq_service, span_type: 'job') do |span|
+            span.resource = job['class']
+            span.set_tag('sidekiq.job.id', job['jid'])
+            span.set_tag('sidekiq.job.retry', job['retry'])
+            span.set_tag('sidekiq.job.queue', job['queue'])
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/app_types.rb

@@ -4,6 +4,7 @@ module Datadog
       WEB = 'web'.freeze
       DB = 'db'.freeze
       CACHE = 'cache'.freeze
+      WORKER = 'worker'.freeze
     end
   end
 end

data/lib/ddtrace/sampler.rb

@@ -0,0 +1,49 @@
+module Datadog
+  # \Sampler performs client-side trace sampling.
+  class Sampler
+    def sample(_span)
+      raise NotImplementedError, 'samplers have to implement the sample() method'
+    end
+  end
+
+  # \AllSampler samples all the traces.
+  class AllSampler < Sampler
+    def sample(span)
+      span.sampled = true
+    end
+  end
+
+  # \RateSampler is based on a sample rate.
+  class RateSampler < Sampler
+    KNUTH_FACTOR = 1111111111111111111
+    SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze()
+
+    attr_reader :sample_rate
+
+    # Initialize a \RateSampler.
+    # This sampler keeps a random subset of the traces. Its main purpose is to
+    # reduce the instrumentation footprint.
+    #
+    # * +sample_rate+: the sample rate as a \Float between 0.0 and 1.0. 0.0
+    #   means that no trace will be sampled; 1.0 means that all traces will be
+    #   sampled.
+    def initialize(sample_rate = 1.0)
+      unless sample_rate > 0.0 && sample_rate <= 1.0
+        Datadog::Tracer.log.error('sample rate is not between 0 and 1, disabling the sampler')
+        sample_rate = 1.0
+      end
+
+      self.sample_rate = sample_rate
+    end
+
+    def sample_rate=(sample_rate)
+      @sample_rate = sample_rate
+      @sampling_id_threshold = sample_rate * Span::MAX_ID
+    end
+
+    def sample(span)
+      span.sampled = ((span.trace_id * KNUTH_FACTOR) % Datadog::Span::MAX_ID) <= @sampling_id_threshold
+      span.set_metric(SAMPLE_RATE_METRIC_KEY, @sample_rate)
+    end
+  end
+end

data/lib/ddtrace/span.rb

@@ -16,7 +16,7 @@ module Datadog
     attr_accessor :name, :service, :resource, :span_type,
                   :start_time, :end_time,
                   :span_id, :trace_id, :parent_id,
-                  :status, :parent
+                  :status, :parent, :sampled
 
     # Create a new span linked to the given tracer. Call the <tt>finish()</tt> method once the
     # tracer operation is over or use the <tt>finish_at(time)</tt> helper to close the span with the
@@ -40,9 +40,11 @@ module Datadog
       @trace_id = options.fetch(:trace_id, @span_id)
 
       @meta = {}
+      @metrics = {}
       @status = 0
 
       @parent = nil
+      @sampled = true
 
       @start_time = Time.now.utc
       @end_time = nil
@@ -55,14 +57,29 @@ module Datadog
     def set_tag(key, value)
       @meta[key] = value.to_s
     rescue StandardError => e
-      Datadog::Tracer.log.error("Unable to set the tag #{key}, ignoring it. Caused by: #{e}")
+      Datadog::Tracer.log.debug("Unable to set the tag #{key}, ignoring it. Caused by: #{e}")
     end
 
-    # Return the tag wth the given key, nil if it doesn't exist.
+    # Return the tag with the given key, nil if it doesn't exist.
     def get_tag(key)
       @meta[key]
     end
 
+    # Set the given key / value metric pair on the span. Keys must be string.
+    # Values must be floating point numbers.
+    def set_metric(key, value)
+      # enforce that the value is a floating point number
+      value = Float(value)
+      @metrics[key] = value
+    rescue StandardError => e
+      Datadog::Tracer.log.debug("Unable to set the metric #{key}, ignoring it. Caused by: #{e}")
+    end
+
+    # Return the metric with the given key, nil if it doesn't exist.
+    def get_metric(key)
+      @metrics[key]
+    end
+
     # Mark the span with the given error.
     def set_error(e)
       return if e.nil?
@@ -122,6 +139,7 @@ module Datadog
         resource: @resource,
         type: @span_type,
         meta: @meta,
+        metrics: @metrics,
         error: @status
       }
 
@@ -151,12 +169,18 @@ module Datadog
         q.text "Start: #{start_time}\n"
         q.text "End: #{end_time}\n"
         q.text "Duration: #{duration}\n"
-        q.group(2, 'Tags: [', ']') do
+        q.group(2, 'Tags: [', "]\n") do
           q.breakable
           q.seplist @meta.each do |key, value|
             q.text "#{key} => #{value}"
           end
         end
+        q.group(2, 'Metrics: [', ']') do
+          q.breakable
+          q.seplist @metrics.each do |key, value|
+            q.text "#{key} => #{value}"
+          end
+        end
       end
     end
   end

data/lib/ddtrace/tracer.rb

@@ -5,6 +5,7 @@ require 'logger'
 require 'ddtrace/span'
 require 'ddtrace/buffer'
 require 'ddtrace/writer'
+require 'ddtrace/sampler'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
@@ -13,7 +14,7 @@ module Datadog
   # Even though the request may require multiple resources and machines to handle the request, all
   # of these function calls and sub-requests would be encapsulated within a single trace.
   class Tracer
-    attr_reader :writer, :services
+    attr_reader :writer, :sampler, :services
     attr_accessor :enabled
 
     # Global, memoized, lazy initialized instance of a logger that is used within the the Datadog
@@ -44,6 +45,8 @@ module Datadog
     def initialize(options = {})
       @enabled = options.fetch(:enabled, true)
       @writer = options.fetch(:writer, Datadog::Writer.new)
+      @sampler = options.fetch(:sampler, Datadog::AllSampler.new)
+
       @buffer = Datadog::SpanBuffer.new()
 
       @mutex = Mutex.new
@@ -66,10 +69,12 @@ module Datadog
       enabled = options.fetch(:enabled, nil)
       hostname = options.fetch(:hostname, nil)
       port = options.fetch(:port, nil)
+      sampler = options.fetch(:sampler, nil)
 
       @enabled = enabled unless enabled.nil?
       @writer.transport.hostname = hostname unless hostname.nil?
       @writer.transport.port = port unless port.nil?
+      @sampler = sampler unless sampler.nil?
     end
 
     # Set the information about the given service. A valid example is:
@@ -121,6 +126,13 @@ module Datadog
       span.set_parent(parent)
       @buffer.set(span)
 
+      # sampling
+      if parent.nil?
+        @sampler.sample(span)
+      else
+        span.sampled = span.parent.sampled
+      end
+
       # call the finish only if a block is given; this ensures
       # that a call to tracer.trace() without a block, returns
       # a span that should be manually finished.
@@ -155,7 +167,7 @@ module Datadog
         @spans = []
       end
 
-      return if spans.empty?
+      return if spans.empty? || !span.sampled
       write(spans)
     end
 

data/lib/ddtrace/version.rb

@@ -1,8 +1,8 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 4
-    PATCH = 3
+    MINOR = 5
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/ddtrace/writer.rb

@@ -9,7 +9,7 @@ module Datadog
     attr_reader :transport
 
     HOSTNAME = 'localhost'.freeze
-    PORT = '7777'.freeze
+    PORT = '8126'.freeze
 
     def initialize(options = {})
       # writer and transport parameters

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -121,12 +121,15 @@ files:
 - gemfiles/rails3_mysql2.gemfile
 - gemfiles/rails3_postgres.gemfile
 - gemfiles/rails3_postgres_redis.gemfile
+- gemfiles/rails3_postgres_sidekiq.gemfile
 - gemfiles/rails4_mysql2.gemfile
 - gemfiles/rails4_postgres.gemfile
 - gemfiles/rails4_postgres_redis.gemfile
+- gemfiles/rails4_postgres_sidekiq.gemfile
 - gemfiles/rails5_mysql2.gemfile
 - gemfiles/rails5_postgres.gemfile
 - gemfiles/rails5_postgres_redis.gemfile
+- gemfiles/rails5_postgres_sidekiq.gemfile
 - lib/ddtrace.rb
 - lib/ddtrace/buffer.rb
 - lib/ddtrace/contrib/elasticsearch/core.rb
@@ -143,6 +146,7 @@ files:
 - lib/ddtrace/contrib/redis/patcher.rb
 - lib/ddtrace/contrib/redis/quantize.rb
 - lib/ddtrace/contrib/redis/tags.rb
+- lib/ddtrace/contrib/sidekiq/tracer.rb
 - lib/ddtrace/contrib/sinatra/tracer.rb
 - lib/ddtrace/encoding.rb
 - lib/ddtrace/ext/app_types.rb
@@ -154,6 +158,7 @@ files:
 - lib/ddtrace/ext/sql.rb
 - lib/ddtrace/monkey.rb
 - lib/ddtrace/pin.rb
+- lib/ddtrace/sampler.rb
 - lib/ddtrace/span.rb
 - lib/ddtrace/tracer.rb
 - lib/ddtrace/transport.rb
@@ -182,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.9
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications