ddtrace 0.18.3 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 690c74d7e00a2fabf4ad03e30b0b40656c8337e9
-  data.tar.gz: dc9f24349943d09fd472b0e5cb9c3b1cff1685ca
+  metadata.gz: f812f568118b7998a52208ffdb4c90a253edfd67
+  data.tar.gz: 914ce035245993d7535152437c720c8c3cca3c2e
 SHA512:
-  metadata.gz: e996f0517f9be72b1b81d36eeedf099f997e66b0d00da4ad4cd93e169a93b6dbcb7e5a8b7df466b11b6487a82236ecfb9c997c908b1337a336c34e07ac78a7be
-  data.tar.gz: 6973e5ff265f3660a19836dd7b02fba398583429c5364e4140cf3231341b855c06596ef33a2a92376f70ead4545326f591a1275ff342f0aba043c1f9ef9dbe46
+  metadata.gz: '08f6d5fe32d68feb4c38ef89ef43908c76884d1b92b30929fc3edd7c50fad58674d21f7e00ff97e4731b008213e9e0584106691d52ed8b1feb16b0dbdac877a0'
+  data.tar.gz: 8b452ada6e2cfb91d1ee170600dc3fc7cd17c0b37042c6a3a746cc5739da038b37457204194f8ecdbc802a85d5afcdb4e79d13bf31293c2226aa0d62dcd0fa66

data/CHANGELOG.md

@@ -4,6 +4,21 @@
 
 ## [Unreleased (beta)]
 
+## [0.19.0] - 2019-01-22
+
+Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.19.0
+
+Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.18.3...v0.19.0
+
+### Added
+
+ - Tracer#active_correlation for adding correlation IDs to logs. (#660, #664, #673)
+ - Opt-in support for `event_sample_rate` tag for some integrations. (#665, #666)
+
+### Changed
+
+ - Priority sampling enabled by default. (#654)
+
 ## [0.18.3] - 2019-01-17
 
 Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.18.3
@@ -627,8 +642,9 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
-[Unreleased (stable)]: https://github.com/DataDog/dd-trace-rb/compare/v0.18.3...master
-[Unreleased (beta)]: https://github.com/DataDog/dd-trace-rb/compare/v0.18.3...0.19-dev
+[Unreleased (stable)]: https://github.com/DataDog/dd-trace-rb/compare/v0.19.0...master
+[Unreleased (beta)]: https://github.com/DataDog/dd-trace-rb/compare/v0.19.0...0.20-dev
+[0.19.0]: https://github.com/DataDog/dd-trace-rb/compare/v0.18.3...v0.19.0
 [0.18.3]: https://github.com/DataDog/dd-trace-rb/compare/v0.18.2...v0.18.3
 [0.18.2]: https://github.com/DataDog/dd-trace-rb/compare/v0.18.1...v0.18.2
 [0.18.1]: https://github.com/DataDog/dd-trace-rb/compare/v0.18.0...v0.18.1

data/Rakefile

@@ -46,7 +46,7 @@ namespace :spec do
   end
 
   RSpec::Core::RakeTask.new(:contrib) do |t|
-    t.pattern = 'spec/**/contrib/{configurable,integration,patchable,patcher,registerable,configuration/*}_spec.rb'
+    t.pattern = 'spec/**/contrib/{configurable,integration,patchable,patcher,registerable,sampling,configuration/*}_spec.rb'
   end
 
   [

data/docs/GettingStarted.md

@@ -62,6 +62,7 @@ For descriptions of terminology used in APM, take a look at the [official docume
      - [Processing pipeline](#processing-pipeline)
          - [Filtering](#filtering)
          - [Processing](#processing)
+     - [Trace correlation](#trace-correlation)
      - [OpenTracing](#opentracing)
 
 ## Compatibility
@@ -517,6 +518,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 | Key | Description | Default |
 | --- | ----------- | ------- |
+| `event_sample_rate` | Rate which spans should be sampled for search and analytics. | `nil` |
 | `service_name` | Service name used for `DelayedJob` instrumentation | `'delayed_job'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
 
@@ -865,6 +867,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 | Key | Description | Default |
 | --- | ----------- | ------- |
+| `event_sample_rate` | Rate which spans should be sampled for search and analytics. | `nil` |
 | `service_name` | Service name used for `racecar` instrumentation | `'racecar'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
 
@@ -897,6 +900,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | --- | ----------- | ------- |
 | `application` | Your Rack application. Required for `middleware_names`. | `nil` |
 | `distributed_tracing` | Enables [distributed tracing](#distributed-tracing) so that this service trace is connected with a trace of another service if tracing headers are received | `false` |
+| `event_sample_rate` | Rate which spans should be sampled for search and analytics. | `nil` |
 | `headers` | Hash of HTTP request or response headers to add as tags to the `rack.request`. Accepts `request` and `response` keys with Array values e.g. `['Last-Modified']`. Adds `http.request.headers.*` and `http.response.headers.*` tags respectively. | `{ response: ['Content-Type', 'X-Request-ID'] }` |
 | `middleware_names` | Enable this if you want to use the middleware classes as the resource names for `rack` spans. Requires `application` option to use. | `false` |
 | `quantize` | Hash containing options for quantization. May include `:query` or `:fragment`. | `{}` |
@@ -1006,6 +1010,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | Key | Description | Default |
 | --- | ----------- | ------- |
 | `enabled` | Defines whether Rake tasks should be traced. Useful for temporarily disabling tracing. `true` or `false` | `true` |
+| `event_sample_rate` | Rate which spans should be sampled for search and analytics. | `nil` |
 | `quantize` | Hash containing options for quantization of task arguments. See below for more details and examples. | `{}` |
 | `service_name` | Service name used for `rake` instrumentation | `'rake'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
@@ -1107,6 +1112,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 | Key | Description | Default |
 | --- | ----------- | ------- |
+| `event_sample_rate` | Rate which spans should be sampled for search and analytics. | `nil` |
 | `service_name` | Service name used for `resque` instrumentation | `'resque'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
 | `workers` | An array including all worker classes you want to trace (eg `[MyJob]`) | `[]` |
@@ -1198,6 +1204,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 | Key | Description | Default |
 | --- | ----------- | ------- |
+| `event_sample_rate` | Rate which spans should be sampled for search and analytics. | `nil` |
 | `service_name` | Service name used for `shoryuken` instrumentation | `'shoryuken'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
 
@@ -1220,6 +1227,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | Key | Description | Default |
 | --- | ----------- | ------- |
 | `client_service_name` | Service name used for client-side `sidekiq` instrumentation | `'sidekiq-client'` |
+| `event_sample_rate` | Rate which spans should be sampled for search and analytics. | `nil` |
 | `service_name` | Service name used for server-side `sidekiq` instrumentation | `'sidekiq'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
 
@@ -1271,6 +1279,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 | Key | Description | Default |
 | --- | ----------- | ------- |
+| `event_sample_rate` | Rate which spans should be sampled for search and analytics. | `nil` |
 | `service_name` | Service name used for `sucker_punch` instrumentation | `'sucker_punch'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
 
@@ -1356,15 +1365,7 @@ The sampler can set the priority to the following values:
  - `Datadog::Ext::Priority::AUTO_REJECT`: the sampler automatically decided to reject the trace.
  - `Datadog::Ext::Priority::AUTO_KEEP`: the sampler automatically decided to keep the trace.
 
-For now, priority sampling is disabled by default. Enabling it ensures that your sampled distributed traces will be complete. To enable the priority sampling:
-
-```ruby
-Datadog.configure do |c|
-  c.tracer priority_sampling: true
-end
-```
-
-Once enabled, the sampler will automatically assign a priority of 0 or 1 to traces, depending on their service and volume.
+Priority sampling is enabled by default. Enabling it ensures that your sampled distributed traces will be complete. Once enabled, the sampler will automatically assign a priority of 0 or 1 to traces, depending on their service and volume.
 
 You can also set this priority manually to either drop a non-interesting trace or to keep an important one. For that, set the `context#sampling_priority` to:
 
@@ -1613,6 +1614,77 @@ Datadog::Pipeline.before_flush(
 )
 ```
 
+### Trace correlation
+
+In many cases, such as logging, it may be useful to correlate trace IDs to other events or data streams, for easier cross referencing. The tracer can produce a correlation identifier for the currently active trace via `active_correlation`, which can be used to decorate these other data sources.
+
+```ruby
+# When a trace is active...
+Datadog.tracer.trace('correlation.example') do
+  # Returns #<Datadog::Correlation::Identifier>
+  correlation = Datadog.tracer.active_correlation
+  correlation.trace_id # => 5963550561812073440
+  correlation.span_id # => 2232727802607726424
+end
+
+# When a trace isn't active...
+correlation = Datadog.tracer.active_correlation
+# Returns #<Datadog::Correlation::Identifier>
+correlation = Datadog.tracer.active_correlation
+correlation.trace_id # => 0
+correlation.span_id # => 0
+```
+
+#### For logging in Ruby applications
+
+To add correlation IDs to your logger, add a log formatter which retrieves the correlation IDs with `Datadog.tracer.active_correlation`, then add them to the message.
+
+To properly correlate with Datadog logging, be sure the following is present:
+
+ - `dd.trace_id=<TRACE_ID>`: Where `<TRACE_ID>` is equal to `Datadog.tracer.active_correlation.trace_id` or `0` if no trace is active.
+ - `dd.span_id=<SPAN_ID>`: Where `<SPAN_ID>` is equal to `Datadog.tracer.active_correlation.span_id` or `0` if no trace is active.
+
+By default, `Datadog::Correlation::Identifier#to_s` will return `dd.trace_id=<TRACE_ID> dd.span_id=<SPAN_ID>`.
+
+An example of this in practice:
+
+```ruby
+require 'ddtrace'
+require 'logger'
+
+logger = Logger.new(STDOUT)
+logger.progname = 'my_app'
+logger.formatter  = proc do |severity, datetime, progname, msg|
+  "[#{datetime}][#{progname}][#{severity}][#{Datadog.tracer.active_correlation}] #{msg}\n"
+end
+
+# When no trace is active
+logger.warn('This is an untraced operation.')
+# [2019-01-16 18:38:41 +0000][my_app][WARN][dd.trace_id=0 dd.span_id=0] This is an untraced operation.
+
+# When a trace is active
+Datadog.tracer.trace('my.operation') { logger.warn('This is a traced operation.') }
+# [2019-01-16 18:38:41 +0000][my_app][WARN][dd.trace_id=8545847825299552251 dd.span_id=3711755234730770098] This is a traced operation.
+```
+
+#### For logging in Rails applications
+
+Rails applications which are configured with a `ActiveSupport::TaggedLogging` logger can append correlation IDs as tags to log output. The default Rails logger implements this tagged logging, making it easier to add correlation tags.
+
+In your Rails environment configuration file, add the following:
+
+```ruby
+Rails.application.configure do
+  config.log_tags = [proc { Datadog.tracer.active_correlation.to_s }]
+end
+
+# Web requests will produce:
+# [dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206] Started GET "/articles" for 172.22.0.1 at 2019-01-16 18:50:57 +0000
+# [dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206] Processing by ArticlesController#index as */*
+# [dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206]   Article Load (0.5ms)  SELECT "articles".* FROM "articles"
+# [dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206] Completed 200 OK in 7ms (Views: 5.5ms | ActiveRecord: 0.5ms)
+```
+
 ### OpenTracing
 
 For setting up Datadog with OpenTracing, see out [Quickstart for OpenTracing](#quickstart-for-opentracing) section for details.

data/lib/ddtrace/contrib/configuration/settings.rb

@@ -9,6 +9,7 @@ module Datadog
 
         option :service_name
         option :tracer, default: Datadog.tracer
+        option :event_sample_rate
 
         def initialize(options = {})
           configure(options)

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -1,4 +1,5 @@
 require 'delayed/plugin'
+require 'ddtrace/contrib/sampling'
 require 'ddtrace/contrib/delayed_job/ext'
 
 module Datadog
@@ -18,6 +19,7 @@ module Datadog
                      end
 
           tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name) do |span|
+            Contrib::Sampling.set_event_sample_rate(span, configuration[:event_sample_rate])
             span.set_tag(Ext::TAG_ID, job.id)
             span.set_tag(Ext::TAG_QUEUE, job.queue) if job.queue
             span.set_tag(Ext::TAG_PRIORITY, job.priority)

data/lib/ddtrace/contrib/racecar/event.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/contrib/sampling'
 require 'ddtrace/contrib/active_support/notifications/event'
 require 'ddtrace/contrib/racecar/ext'
 
@@ -36,6 +37,7 @@ module Datadog
             span.service = configuration[:service_name]
             span.resource = payload[:consumer_class]
 
+            Contrib::Sampling.set_event_sample_rate(span, configuration[:event_sample_rate])
             span.set_tag(Ext::TAG_TOPIC, payload[:topic])
             span.set_tag(Ext::TAG_CONSUMER, payload[:consumer_class])
             span.set_tag(Ext::TAG_PARTITION, payload[:partition])

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

@@ -1,6 +1,7 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/http'
 require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/sampling'
 require 'ddtrace/contrib/rack/ext'
 require 'ddtrace/contrib/rack/request_queue'
 
@@ -25,7 +26,7 @@ module Datadog
         end
 
         def compute_queue_time(env, tracer)
-          return unless Datadog.configuration[:rack][:request_queuing]
+          return unless configuration[:request_queuing]
 
           # parse the request queue time
           request_start = Datadog::Contrib::Rack::QueueTime.get_request_start(env)
@@ -34,25 +35,25 @@ module Datadog
           tracer.trace(
             Ext::SPAN_HTTP_SERVER_QUEUE,
             start_time: request_start,
-            service: Datadog.configuration[:rack][:web_service_name]
+            service: configuration[:web_service_name]
           )
         end
 
         def call(env)
           # retrieve integration settings
-          tracer = Datadog.configuration[:rack][:tracer]
+          tracer = configuration[:tracer]
 
           # [experimental] create a root Span to keep track of frontend web servers
           # (i.e. Apache, nginx) if the header is properly set
           frontend_span = compute_queue_time(env, tracer)
 
           trace_options = {
-            service: Datadog.configuration[:rack][:service_name],
+            service: configuration[:service_name],
             resource: nil,
             span_type: Datadog::Ext::HTTP::TYPE
           }
 
-          if Datadog.configuration[:rack][:distributed_tracing]
+          if configuration[:distributed_tracing]
             context = HTTPPropagator.extract(env)
             tracer.provider.context = context if context.trace_id
           end
@@ -114,7 +115,7 @@ module Datadog
         end
 
         def resource_name_for(env, status)
-          if Datadog.configuration[:rack][:middleware_names] && env['RESPONSE_MIDDLEWARE']
+          if configuration[:middleware_names] && env['RESPONSE_MIDDLEWARE']
             "#{env['RESPONSE_MIDDLEWARE']}##{env['REQUEST_METHOD']}"
           else
             "#{env['REQUEST_METHOD']} #{status}".strip
@@ -138,13 +139,19 @@ module Datadog
           response_headers = parse_response_headers(headers || {})
 
           request_span.resource ||= resource_name_for(env, status)
+
+          # Set event sample rate, if available.
+          Contrib::Sampling.set_event_sample_rate(request_span, configuration[:event_sample_rate])
+
           if request_span.get_tag(Datadog::Ext::HTTP::METHOD).nil?
             request_span.set_tag(Datadog::Ext::HTTP::METHOD, env['REQUEST_METHOD'])
           end
+
           if request_span.get_tag(Datadog::Ext::HTTP::URL).nil?
-            options = Datadog.configuration[:rack][:quantize]
+            options = configuration[:quantize]
             request_span.set_tag(Datadog::Ext::HTTP::URL, Datadog::Quantization::HTTP.url(url, options))
           end
+
           if request_span.get_tag(Datadog::Ext::HTTP::BASE_URL).nil?
             request_obj = ::Rack::Request.new(env)
 
@@ -157,6 +164,7 @@ module Datadog
 
             request_span.set_tag(Datadog::Ext::HTTP::BASE_URL, base_url)
           end
+
           if request_span.get_tag(Datadog::Ext::HTTP::STATUS_CODE).nil? && status
             request_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, status)
           end
@@ -186,6 +194,10 @@ module Datadog
           If you need the Rack request span, try using `Datadog.tracer.active_span`.
           This key will be removed in version 1.0).freeze
 
+        def configuration
+          Datadog.configuration[:rack]
+        end
+
         def add_deprecation_warnings(env)
           env.instance_eval do
             unless instance_variable_defined?(:@patched_with_datadog_warnings)
@@ -225,7 +237,7 @@ module Datadog
 
         def parse_request_headers(env)
           {}.tap do |result|
-            whitelist = Datadog.configuration[:rack][:headers][:request] || []
+            whitelist = configuration[:headers][:request] || []
             whitelist.each do |header|
               rack_header = header_to_rack_header(header)
               if env.key?(rack_header)
@@ -237,7 +249,7 @@ module Datadog
 
         def parse_response_headers(headers)
           {}.tap do |result|
-            whitelist = Datadog.configuration[:rack][:headers][:response] || []
+            whitelist = configuration[:headers][:response] || []
             whitelist.each do |header|
               if headers.key?(header)
                 result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[header]

data/lib/ddtrace/contrib/rake/instrumentation.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/contrib/sampling'
 require 'ddtrace/contrib/rake/ext'
 
 module Datadog
@@ -41,6 +42,7 @@ module Datadog
 
           def annotate_invoke!(span, args)
             span.resource = name
+            Contrib::Sampling.set_event_sample_rate(span, configuration[:event_sample_rate])
             span.set_tag(Ext::TAG_TASK_ARG_NAMES, arg_names)
             span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
           rescue StandardError => e

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

@@ -19,7 +19,6 @@ module Datadog
           do_once(:resque) do
             begin
               require_relative 'resque_job'
-              add_pin
               get_option(:workers).each { |worker| worker.extend(ResqueJob) }
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply Resque integration: #{e}")
@@ -27,15 +26,6 @@ module Datadog
           end
         end
 
-        def add_pin
-          Pin.new(
-            get_option(:service_name),
-            app: Ext::APP,
-            app_type: Datadog::Ext::AppTypes::WORKER,
-            tracer: get_option(:tracer)
-          ).onto(::Resque)
-        end
-
         def get_option(option)
           Datadog.configuration[:resque].get_option(option)
         end

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

@@ -1,5 +1,6 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/sync_writer'
+require 'ddtrace/contrib/sampling'
 require 'ddtrace/contrib/sidekiq/ext'
 require 'resque'
 
@@ -9,13 +10,13 @@ module Datadog
       # Uses Resque job hooks to create traces
       module ResqueJob
         def around_perform(*_)
-          pin = Pin.get_from(::Resque)
-          return yield unless pin && pin.tracer
-          pin.tracer.trace(Ext::SPAN_JOB, service: pin.service) do |span|
+          return yield unless datadog_configuration && tracer
+
+          tracer.trace(Ext::SPAN_JOB, span_options) do |span|
             span.resource = name
-            span.span_type = pin.app_type
+            span.span_type = Datadog::Ext::AppTypes::WORKER
+            Contrib::Sampling.set_event_sample_rate(span, datadog_configuration[:event_sample_rate])
             yield
-            span.service = pin.service
           end
         end
 
@@ -28,8 +29,27 @@ module Datadog
         end
 
         def shutdown_tracer_when_forked!
-          pin = Datadog::Pin.get_from(Resque)
-          pin.tracer.shutdown! if pin && pin.tracer && pin.config && pin.config[:forked]
+          tracer.shutdown! if forked?
+        end
+
+        private
+
+        def forked?
+          pin = Datadog::Pin.get_from(::Resque)
+          return false unless pin
+          pin.config[:forked] == true
+        end
+
+        def span_options
+          { service: datadog_configuration[:service_name] }
+        end
+
+        def tracer
+          datadog_configuration.tracer
+        end
+
+        def datadog_configuration
+          Datadog.configuration[:resque]
         end
       end
     end
@@ -37,12 +57,17 @@ module Datadog
 end
 
 Resque.after_fork do
-  # get the current tracer
-  pin = Datadog::Pin.get_from(Resque)
-  next unless pin && pin.tracer
-  pin.config ||= {}
-  pin.config[:forked] = true
-
-  # clean the state so no CoW happens
-  pin.tracer.provider.context = nil
+  configuration = Datadog.configuration[:resque]
+  next if configuration.nil?
+
+  # Add a pin, marking the job as forked.
+  # Used to trigger shutdown in forks for performance reasons.
+  Datadog::Pin.new(
+    configuration[:service_name],
+    config: { forked: true }
+  ).onto(::Resque)
+
+  # Clean the state so no CoW happens
+  next if configuration[:tracer].nil?
+  configuration[:tracer].provider.context = nil
 end

data/lib/ddtrace/contrib/sampling.rb

@@ -0,0 +1,14 @@
+require 'ddtrace/ext/priority'
+
+module Datadog
+  module Contrib
+    # Defines sampling behavior for integrations
+    module Sampling
+      module_function
+
+      def set_event_sample_rate(span, sample_rate)
+        span.set_metric(Datadog::Ext::Priority::TAG_EVENT_SAMPLE_RATE, sample_rate) unless sample_rate.nil?
+      end
+    end
+  end
+end

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

@@ -1,16 +1,19 @@
+require 'ddtrace/contrib/sampling'
+
 module Datadog
   module Contrib
     module Shoryuken
       # Tracer is a Shoryuken server-side middleware which traces executed jobs
       class Tracer
         def initialize(options = {})
-          @tracer = options[:tracer] || Datadog.configuration[:shoryuken][:tracer]
-          @shoryuken_service = options[:service_name] || Datadog.configuration[:shoryuken][:service_name]
+          @tracer = options[:tracer] || configuration[:tracer]
+          @shoryuken_service = options[:service_name] || configuration[:service_name]
           set_service_info(@shoryuken_service)
         end
 
         def call(worker_instance, queue, sqs_msg, body)
           @tracer.trace(Ext::SPAN_JOB, service: @shoryuken_service, span_type: Datadog::Ext::AppTypes::WORKER) do |span|
+            Contrib::Sampling.set_event_sample_rate(span, configuration[:event_sample_rate])
             span.resource = resource(worker_instance, body)
             span.set_tag(Ext::TAG_JOB_ID, sqs_msg.message_id)
             span.set_tag(Ext::TAG_JOB_QUEUE, queue)
@@ -31,8 +34,12 @@ module Datadog
           job_class || worker_instance.class.name
         end
 
+        def configuration
+          Datadog.configuration[:shoryuken]
+        end
+
         def set_service_info(service)
-          return if @tracer.services[service]
+          return if @tracer.nil? || @tracer.services[service]
           @tracer.set_service_info(
             service,
             Ext::APP,

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

@@ -1,4 +1,5 @@
 require 'ddtrace/contrib/sidekiq/tracing'
+require 'ddtrace/contrib/sampling'
 
 module Datadog
   module Contrib
@@ -9,19 +10,18 @@ module Datadog
 
         def initialize(options = {})
           super
-          @sidekiq_service = options[:client_service_name] || Datadog.configuration[:sidekiq][:client_service_name]
+          @sidekiq_service = options[:client_service_name] || configuration[:client_service_name]
+          set_service_info(@sidekiq_service)
         end
 
         # Client middleware arguments are documented here:
         #   https://github.com/mperham/sidekiq/wiki/Middleware#client-middleware
         def call(worker_class, job, queue, redis_pool)
-          service = @sidekiq_service
-          set_service_info(service)
-
           resource = job_resource(job)
 
-          @tracer.trace(Ext::SPAN_PUSH, service: service) do |span|
+          @tracer.trace(Ext::SPAN_PUSH, service: @sidekiq_service) do |span|
             span.resource = resource
+            Contrib::Sampling.set_event_sample_rate(span, configuration[:event_sample_rate])
             span.set_tag(Ext::TAG_JOB_ID, job['jid'])
             span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
             span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
@@ -29,6 +29,12 @@ module Datadog
             yield
           end
         end
+
+        private
+
+        def configuration
+          Datadog.configuration[:sidekiq]
+        end
       end
     end
   end

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

@@ -1,4 +1,5 @@
 require 'ddtrace/contrib/sidekiq/tracing'
+require 'ddtrace/contrib/sampling'
 
 module Datadog
   module Contrib
@@ -9,7 +10,7 @@ module Datadog
 
         def initialize(options = {})
           super
-          @sidekiq_service = options[:service_name] || Datadog.configuration[:sidekiq][:service_name]
+          @sidekiq_service = options[:service_name] || configuration[:service_name]
         end
 
         def call(worker, job, queue)
@@ -20,6 +21,7 @@ module Datadog
 
           @tracer.trace(Ext::SPAN_JOB, service: service, span_type: Datadog::Ext::AppTypes::WORKER) do |span|
             span.resource = resource
+            Contrib::Sampling.set_event_sample_rate(span, configuration[:event_sample_rate])
             span.set_tag(Ext::TAG_JOB_ID, job['jid'])
             span.set_tag(Ext::TAG_JOB_RETRY, job['retry'])
             span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
@@ -32,6 +34,10 @@ module Datadog
 
         private
 
+        def configuration
+          Datadog.configuration[:sidekiq]
+        end
+
         def service_from_worker_config(resource)
           # Try to get the Ruby class from the resource name.
           worker_klass = begin

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

@@ -1,4 +1,5 @@
 require 'sucker_punch'
+require 'ddtrace/contrib/sampling'
 require 'ddtrace/contrib/sucker_punch/ext'
 
 module Datadog
@@ -18,6 +19,7 @@ module Datadog
 
               __with_instrumentation(Ext::SPAN_PERFORM) do |span|
                 span.resource = "PROCESS #{self}"
+                Contrib::Sampling.set_event_sample_rate(span, datadog_configuration[:event_sample_rate])
                 __run_perform_without_datadog(*args)
               end
             rescue => e
@@ -43,6 +45,10 @@ module Datadog
 
             private
 
+            def datadog_configuration
+              Datadog.configuration[:sucker_punch]
+            end
+
             def __with_instrumentation(name)
               pin = Datadog::Pin.get_from(::SuckerPunch)
 

data/lib/ddtrace/correlation.rb

@@ -0,0 +1,32 @@
+module Datadog
+  # Contains behavior for managing correlations with tracing
+  # e.g. Retrieve a correlation to the current trace for logging, etc.
+  module Correlation
+    # Struct representing correlation
+    Identifier = Struct.new(:trace_id, :span_id).tap do |struct|
+      # Do this #class_eval here for Ruby 1.9.3 support.
+      # Ruby 2.0+ supports passing a block to Struct::new instead.
+      struct.class_eval do
+        def initialize(*args)
+          super
+          self.trace_id = trace_id || 0
+          self.span_id = span_id || 0
+        end
+
+        def to_s
+          "dd.trace_id=#{trace_id} dd.span_id=#{span_id}"
+        end
+      end
+    end.freeze
+
+    NULL_IDENTIFIER = Identifier.new.freeze
+
+    module_function
+
+    # Produces a CorrelationIdentifier from the Context provided
+    def identifier_from_context(context)
+      return NULL_IDENTIFIER if context.nil?
+      Identifier.new(context.trace_id, context.span_id).freeze
+    end
+  end
+end

data/lib/ddtrace/ext/priority.rb

@@ -3,6 +3,8 @@ module Datadog
     # Priority is a hint given to the backend so that it knows which traces to reject or kept.
     # In a distributed context, it should be set before any context propagation (fork, RPC calls) to be effective.
     module Priority
+      # Tag for span sample rate; used by agent to determine whether event is emitted.
+      TAG_EVENT_SAMPLE_RATE = '_dd1.sr.eausr'.freeze
       # Use this to explicitely inform the backend that a trace should be rejected and not stored.
       USER_REJECT = -1
       # Used by the builtin sampler to inform the backend that a trace should be rejected and not stored.

data/lib/ddtrace/tracer.rb

@@ -10,6 +10,7 @@ require 'ddtrace/provider'
 require 'ddtrace/logger'
 require 'ddtrace/writer'
 require 'ddtrace/sampler'
+require 'ddtrace/correlation'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
@@ -126,7 +127,7 @@ module Datadog
 
       # Those are rare "power-user" options.
       sampler = options.fetch(:sampler, nil)
-      priority_sampling = options[:priority_sampling]
+      priority_sampling = options.fetch(:priority_sampling, nil)
       max_spans_before_partial_flush = options.fetch(:max_spans_before_partial_flush, nil)
       min_spans_before_partial_flush = options.fetch(:min_spans_before_partial_flush, nil)
       partial_flush_timeout = options.fetch(:partial_flush_timeout, nil)
@@ -134,9 +135,15 @@ module Datadog
       @enabled = enabled unless enabled.nil?
       @sampler = sampler unless sampler.nil?
 
-      if priority_sampling
+      # Re-build the sampler and writer if priority sampling is enabled,
+      # but neither are configured. Verify the sampler isn't already a
+      # priority sampler too, so we don't wrap one with another.
+      if priority_sampling != false && !@sampler.is_a?(PrioritySampler)
         @sampler = PrioritySampler.new(base_sampler: @sampler)
         @writer = Writer.new(priority_sampler: @sampler)
+      elsif priority_sampling == false
+        @sampler = sampler || Datadog::AllSampler.new if @sampler.is_a?(PrioritySampler)
+        @writer = Writer.new
       end
 
       @writer.transport.hostname = hostname unless hostname.nil?
@@ -351,6 +358,11 @@ module Datadog
       call_context.current_root_span
     end
 
+    # Return a CorrelationIdentifier for active span
+    def active_correlation
+      Datadog::Correlation.identifier_from_context(call_context)
+    end
+
     # Send the trace to the writer to enqueue the spans list in the agent
     # sending queue.
     def write(trace)

data/lib/ddtrace/version.rb

@@ -1,8 +1,8 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 18
-    PATCH = 3
+    MINOR = 19
+    PATCH = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.19.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-17 00:00:00.000000000 Z
+date: 2019-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -449,6 +449,7 @@ files:
 - lib/ddtrace/contrib/rest_client/integration.rb
 - lib/ddtrace/contrib/rest_client/patcher.rb
 - lib/ddtrace/contrib/rest_client/request_patch.rb
+- lib/ddtrace/contrib/sampling.rb
 - lib/ddtrace/contrib/sequel/configuration/settings.rb
 - lib/ddtrace/contrib/sequel/database.rb
 - lib/ddtrace/contrib/sequel/dataset.rb
@@ -482,6 +483,7 @@ files:
 - lib/ddtrace/contrib/sucker_punch/instrumentation.rb
 - lib/ddtrace/contrib/sucker_punch/integration.rb
 - lib/ddtrace/contrib/sucker_punch/patcher.rb
+- lib/ddtrace/correlation.rb
 - lib/ddtrace/encoding.rb
 - lib/ddtrace/error.rb
 - lib/ddtrace/ext/app_types.rb