ddtrace 0.21.2 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61acb994baa0c01a709084beac147a5c6052e92d
-  data.tar.gz: bd4846e16ff33ddd1e6b8a88b080ed79c0958190
+  metadata.gz: ca30d1de4944896da5082d6e5479437c7ec76ae8
+  data.tar.gz: 1a9d2c6922699e01f6364039d5ff39530c7fb6fd
 SHA512:
-  metadata.gz: a55674e8f2d82acd24ee34458af85d3555948854439cb84ab85d3f4c496235e28d14809aa10925fecc9af91e484d7b996f6d6de684351c22d4ef4f1be2e3ed5d
-  data.tar.gz: 90a143ebed788d5c90902866d126a40d2f5ba8f640eb98b66a2efa79e1eee1571c974d62aefd38192024c7836324de972a89b0bf90136125ef0e8c0ab6f6e358
+  metadata.gz: '01378c87cbd74c47525e7b5eed4fa161305b3f7c1a0da54e6c105074806b5c32af84b27d69e7251ba39cc5d7040f4335f3eb878e30bd3a2f6cf08d317f75c4e8'
+  data.tar.gz: e08463b5ad5f4a67af403558bcb5a51fe9a7a4451804037ac5db6203280cb263dde1e02d78c9fc4973e12a07aa44f6334b6b79f337bc34c7fc5d8eb0118b0182

data/.env

@@ -1,4 +1,5 @@
 DD_AGENT_HOST=localhost
+DD_METRIC_AGENT_PORT=8125
 DD_TRACE_AGENT_PORT=8126
 TEST_DDAGENT_API_KEY=invalid_key_but_this_is_fine
 TEST_ELASTICSEARCH_HOST=127.0.0.1

data/CHANGELOG.md

@@ -4,6 +4,22 @@
 
 ## [Unreleased (beta)]
 
+## [0.22.0] - 2019-04-15
+
+Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.22.0
+
+Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.21.2...v0.22.0
+
+In this release we are adding initial support for the **beta** [Runtime metrics collection](https://docs.datadoghq.com/tracing/advanced/runtime_metrics/?tab=ruby) feature.
+
+### Changed
+
+- Add warning log if an integration is incompatible (#722) (@ericmustin)
+
+### Added
+
+- Initial beta support for Runtime metrics collection (#677)
+
 ## [0.21.2] - 2019-04-10
 
 Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.21.2
@@ -751,8 +767,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.21.2...master
-[Unreleased (beta)]: https://github.com/DataDog/dd-trace-rb/compare/v0.21.2...0.22-dev
+[Unreleased (stable)]: https://github.com/DataDog/dd-trace-rb/compare/v0.22.0...master
+[Unreleased (beta)]: https://github.com/DataDog/dd-trace-rb/compare/v0.22.0...0.23-dev
+[0.22.0]: https://github.com/DataDog/dd-trace-rb/compare/v0.21.2...v0.22.0
 [0.21.2]: https://github.com/DataDog/dd-trace-rb/compare/v0.21.1...v0.21.2
 [0.21.1]: https://github.com/DataDog/dd-trace-rb/compare/v0.21.0...v0.21.1
 [0.21.0]: https://github.com/DataDog/dd-trace-rb/compare/v0.20.0...v0.21.0

data/Rakefile

@@ -15,39 +15,47 @@ namespace :spec do
              :rails, :railsredis, :railssidekiq, :railsactivejob,
              :elasticsearch, :http, :redis, :sidekiq, :sinatra]
 
-  RSpec::Core::RakeTask.new(:main) do |t|
+  RSpec::Core::RakeTask.new(:main) do |t, args|
     t.pattern = 'spec/**/*_spec.rb'
     t.exclude_pattern = 'spec/**/{contrib,benchmark,redis,opentracer}/**/*_spec.rb'
+    t.rspec_opts = args.to_a.join(' ')
   end
 
-  RSpec::Core::RakeTask.new(:opentracer) do |t|
+  RSpec::Core::RakeTask.new(:opentracer) do |t, args|
     t.pattern = 'spec/ddtrace/opentracer/**/*_spec.rb'
+    t.rspec_opts = args.to_a.join(' ')
   end
 
-  RSpec::Core::RakeTask.new(:rails) do |t|
+  RSpec::Core::RakeTask.new(:rails) do |t, args|
     t.pattern = 'spec/ddtrace/contrib/rails/**/*_spec.rb'
     t.exclude_pattern = 'spec/ddtrace/contrib/rails/**/*{sidekiq,active_job,disable_env}*_spec.rb'
+    t.rspec_opts = args.to_a.join(' ')
   end
 
-  RSpec::Core::RakeTask.new(:railsredis) do |t|
+  RSpec::Core::RakeTask.new(:railsredis) do |t, args|
     t.pattern = 'spec/ddtrace/contrib/rails/**/*redis*_spec.rb'
+    t.rspec_opts = args.to_a.join(' ')
   end
 
-  RSpec::Core::RakeTask.new(:railssidekiq) do |t|
+  RSpec::Core::RakeTask.new(:railssidekiq) do |t, args|
     t.pattern = 'spec/ddtrace/contrib/rails/**/*sidekiq*_spec.rb'
+    t.rspec_opts = args.to_a.join(' ')
   end
 
-  RSpec::Core::RakeTask.new(:railsactivejob) do |t|
+  RSpec::Core::RakeTask.new(:railsactivejob) do |t, args|
     t.pattern = 'spec/ddtrace/contrib/rails/**/*active_job*_spec.rb'
+    t.rspec_opts = args.to_a.join(' ')
   end
 
-  RSpec::Core::RakeTask.new(:railsdisableenv) do |t|
+  RSpec::Core::RakeTask.new(:railsdisableenv) do |t, args|
     t.pattern = 'spec/ddtrace/contrib/rails/**/*disable_env*_spec.rb'
+    t.rspec_opts = args.to_a.join(' ')
   end
 
-  RSpec::Core::RakeTask.new(:contrib) do |t|
+  RSpec::Core::RakeTask.new(:contrib) do |t, args|
     # rubocop:disable Metrics/LineLength
     t.pattern = 'spec/**/contrib/{analytics,configurable,integration,patchable,patcher,registerable,registry,configuration/*}_spec.rb'
+    t.rspec_opts = args.to_a.join(' ')
   end
 
   [
@@ -79,8 +87,9 @@ namespace :spec do
     :sucker_punch,
     :shoryuken
   ].each do |contrib|
-    RSpec::Core::RakeTask.new(contrib) do |t|
+    RSpec::Core::RakeTask.new(contrib) do |t, args|
       t.pattern = "spec/ddtrace/contrib/#{contrib}/**/*_spec.rb"
+      t.rspec_opts = args.to_a.join(' ')
     end
   end
 end

data/ddtrace.gemspec

@@ -33,10 +33,13 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'msgpack'
+
+  # Optional extensions
   # TODO: Move this to Appraisals?
-  spec.add_dependency 'opentracing', '>= 0.4.1'
+  spec.add_development_dependency 'dogstatsd-ruby', '>= 3.3.0'
+  spec.add_development_dependency 'opentracing', '>= 0.4.1'
 
-  spec.add_development_dependency 'climate_control', '~> 0.2.0'
+  # Development dependencies
   spec.add_development_dependency 'rake', '>= 10.5'
   spec.add_development_dependency 'rubocop', '= 0.49.1' if RUBY_VERSION >= '2.1.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
@@ -48,6 +51,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'builder'
   spec.add_development_dependency 'ruby-prof'
   spec.add_development_dependency 'sqlite3', '~> 1.3.6'
+  spec.add_development_dependency 'climate_control', '~> 0.2.0'
 
   # locking transitive dependency of webmock
   spec.add_development_dependency 'addressable', '~> 2.4.0'

data/docker-compose.yml

@@ -175,8 +175,10 @@ services:
       - DD_BIND_HOST=0.0.0.0
       - DD_API_KEY=invalid_key_but_this_is_fine
     expose:
+      - "8125/udp"
       - "8126"
     ports:
+      - "${DD_METRIC_AGENT_PORT}:8125/udp"
       - "${DD_TRACE_AGENT_PORT}:8126"
   elasticsearch:
     # Note: ES 5.0 dies with error:

data/docs/GettingStarted.md

@@ -63,6 +63,8 @@ For descriptions of terminology used in APM, take a look at the [official docume
          - [Filtering](#filtering)
          - [Processing](#processing)
      - [Trace correlation](#trace-correlation)
+     - [Metrics](#metrics)
+         - [For application runtime](#for-application-runtime)
      - [OpenTracing](#opentracing)
 
 ## Compatibility
@@ -1725,6 +1727,56 @@ 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.
 ```
 
+### Metrics
+
+The tracer and its integrations can produce some additional metrics that can provide useful insight into the performance of your application. These metrics are collected with `dogstatsd-ruby`, and can be sent to the same Datadog agent to which you send your traces.
+
+To configure your application for metrics collection:
+
+1. [Configure your Datadog agent for StatsD](https://docs.datadoghq.com/developers/dogstatsd/#setup)
+2. Add `gem 'dogstatsd-ruby'` to your Gemfile
+
+#### For application runtime
+
+If runtime metrics are configured, the trace library will automatically collect and send metrics about the health of your application.
+
+To configure runtime metrics, add the following configuration:
+
+```ruby
+# config/initializers/datadog.rb
+require 'datadog/statsd'
+require 'ddtrace'
+
+Datadog.configure do |c|
+  # To enable runtime metrics collection, set `true`. Defaults to `false`
+  # You can also set DD_RUNTIME_METRICS_ENABLED=true to configure this.
+  c.runtime_metrics_enabled = true
+
+  # Optionally, you can configure the Statsd instance used for sending runtime metrics.
+  # Statsd is automatically configured with default settings if `dogstatsd-ruby` is available.
+  # You can configure with host and port of Datadog agent; defaults to 'localhost:8125'.
+  c.runtime_metrics statsd: Datadog::Statsd.new
+end
+```
+
+See the [Dogstatsd documentation](https://www.rubydoc.info/github/DataDog/dogstatsd-ruby/master/frames) for more details about configuring `Datadog::Statsd`.
+
+The stats sent will include:
+
+| Name                        | Type    | Description                                              |
+| --------------------------  | ------- | -------------------------------------------------------- |
+| `runtime.ruby.class_count`  | `gauge` | Number of classes in memory space.                       |
+| `runtime.ruby.thread_count` | `gauge` | Number of threads.                                       |
+| `runtime.ruby.gc.*`.        | `gauge` | Garbage collection statistics (one per value in GC.stat) |
+
+In addition, all metrics will include the following tags:
+
+| Name         | Description                                             |
+| ------------ | ------------------------------------------------------- |
+| `language`   | Programming language traced. (e.g. `ruby`)              |
+| `runtime-id` | Unique identifier of runtime environment (i.e. process) |
+| `service`    | List of services this metric is associated with.        |
+
 ### OpenTracing
 
 For setting up Datadog with OpenTracing, see out [Quickstart for OpenTracing](#quickstart-for-opentracing) section for details.

data/lib/ddtrace.rb

@@ -9,6 +9,7 @@ require 'ddtrace/pipeline'
 require 'ddtrace/configuration'
 require 'ddtrace/patcher'
 require 'ddtrace/augmentation'
+require 'ddtrace/metrics'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog

data/lib/ddtrace/configuration.rb

@@ -22,5 +22,9 @@ module Datadog
     def tracer
       configuration.tracer
     end
+
+    def runtime_metrics
+      tracer.writer.runtime_metrics
+    end
   end
 end

data/lib/ddtrace/configuration/settings.rb

@@ -1,7 +1,11 @@
 require 'ddtrace/ext/analytics'
-require 'ddtrace/environment'
+require 'ddtrace/ext/runtime'
 require 'ddtrace/configuration/options'
 
+require 'ddtrace/environment'
+require 'ddtrace/tracer'
+require 'ddtrace/metrics'
+
 module Datadog
   module Configuration
     # Global configuration settings for the trace library.
@@ -13,6 +17,10 @@ module Datadog
               default: -> { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) },
               lazy: true
 
+      option  :runtime_metrics_enabled,
+              default: -> { env_to_bool(Ext::Runtime::Metrics::ENV_ENABLED, false) },
+              lazy: true
+
       option :tracer, default: Tracer.new
 
       def initialize(options = {})
@@ -28,7 +36,15 @@ module Datadog
         yield(self) if block_given?
       end
 
+      def runtime_metrics(options = nil)
+        runtime_metrics = get_option(:tracer).writer.runtime_metrics
+        return runtime_metrics if options.nil?
+
+        runtime_metrics.configure(options)
+      end
+
       # Backwards compatibility for configuring tracer e.g. `c.tracer debug: true`
+      remove_method :tracer
       def tracer(options = nil)
         tracer = options && options.key?(:instance) ? set_option(:tracer, options[:instance]) : get_option(:tracer)
 

data/lib/ddtrace/context.rb

@@ -200,14 +200,14 @@ module Datadog
     end
 
     def attach_sampling_priority
-      @trace.first.set_metric(
+      @current_root_span.set_metric(
         Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
         @sampling_priority
       )
     end
 
     def attach_origin
-      @trace.first.set_tag(
+      @current_root_span.set_tag(
         Ext::DistributedTracing::ORIGIN_KEY,
         @origin
       )

data/lib/ddtrace/contrib/patchable.rb

@@ -29,7 +29,11 @@ module Datadog
         end
 
         def patch
-          return if !self.class.compatible? || patcher.nil?
+          if !self.class.compatible? || patcher.nil?
+            Datadog::Tracer.log.warn("Unable to patch #{self.class.name}")
+            return
+          end
+
           patcher.patch
         end
       end

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

@@ -124,6 +124,7 @@ module Datadog
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def set_request_tags!(request_span, env, status, headers, response, original_env)
           # http://www.rubydoc.info/github/rack/rack/file/SPEC
           # The source of truth in Rack is the PATH_INFO key that holds the
@@ -142,6 +143,9 @@ module Datadog
 
           request_span.resource ||= resource_name_for(env, status)
 
+          # Associate with runtime metrics
+          Datadog.runtime_metrics.associate_with_span(request_span)
+
           # Set analytics sample rate
           if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
             Contrib::Analytics.set_sample_rate(request_span, configuration[:analytics_sample_rate])

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

@@ -53,6 +53,9 @@ module Datadog
             # Set analytics sample rate
             Utils.set_analytics_sample_rate(span)
 
+            # Associate with runtime metrics
+            Datadog.runtime_metrics.associate_with_span(span)
+
             span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
             span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
 

data/lib/ddtrace/ext/metrics.rb

@@ -0,0 +1,11 @@
+module Datadog
+  module Ext
+    module Metrics
+      TAG_LANG = 'language'.freeze
+      TAG_LANG_INTERPRETER = 'language-interpreter'.freeze
+      TAG_LANG_VERSION = 'language-version'.freeze
+      TAG_RUNTIME_ID = 'runtime-id'.freeze
+      TAG_TRACER_VERSION = 'tracer-version'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/runtime.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/version'
+
+module Datadog
+  module Ext
+    module Runtime
+      # Identity
+      LANG = 'ruby'.freeze
+      LANG_INTERPRETER = begin
+        if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('1.9')
+          (RUBY_ENGINE + '-' + RUBY_PLATFORM)
+        else
+          ('ruby-' + RUBY_PLATFORM)
+        end
+      end.freeze
+      LANG_VERSION = RUBY_VERSION
+      TRACER_VERSION = Datadog::VERSION::STRING
+
+      TAG_LANG = 'language'.freeze
+      TAG_RUNTIME_ID = 'runtime-id'.freeze
+
+      # Metrics
+      module Metrics
+        ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'.freeze
+
+        METRIC_CLASS_COUNT = 'runtime.ruby.class_count'.freeze
+        METRIC_GC_PREFIX = 'runtime.ruby.gc'.freeze
+        METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'.freeze
+
+        TAG_SERVICE = 'service'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/metrics.rb

@@ -0,0 +1,131 @@
+require 'ddtrace/ext/metrics'
+
+require 'set'
+require 'ddtrace/utils/time'
+require 'ddtrace/runtime/identity'
+
+module Datadog
+  # Acts as client for sending metrics (via Statsd)
+  # Wraps a Statsd client with default tags and additional configuration.
+  class Metrics
+    DEFAULT_AGENT_HOST = '127.0.0.1'.freeze
+    DEFAULT_METRIC_AGENT_PORT = '8125'.freeze
+
+    attr_reader :statsd
+
+    def initialize(options = {})
+      @statsd = options.fetch(:statsd) { default_statsd_client if supported? }
+      @enabled = options.fetch(:enabled, true)
+    end
+
+    def supported?
+      Gem.loaded_specs['dogstatsd-ruby'] \
+        && Gem.loaded_specs['dogstatsd-ruby'].version >= Gem::Version.new('3.3.0')
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def enabled=(enabled)
+      @enabled = (enabled == true)
+    end
+
+    def default_statsd_client
+      require 'datadog/statsd' unless defined?(::Datadog::Statsd)
+
+      # Create a StatsD client that points to the agent.
+      Datadog::Statsd.new(
+        ENV.fetch('DD_AGENT_HOST', DEFAULT_AGENT_HOST),
+        ENV.fetch('DD_METRIC_AGENT_PORT', DEFAULT_METRIC_AGENT_PORT)
+      )
+    end
+
+    def configure(options = {})
+      @statsd = options[:statsd] if options.key?(:statsd)
+      @enabled = options[:enabled] if options.key?(:enabled)
+    end
+
+    def send_stats?
+      enabled? && !statsd.nil?
+    end
+
+    def distribution(stat, value, options = nil)
+      return unless send_stats? && statsd.respond_to?(:distribution)
+      statsd.distribution(stat, value, metric_options(options))
+    rescue StandardError => e
+      Datadog::Tracer.log.error("Failed to send distribution stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def increment(stat, options = nil)
+      return unless send_stats? && statsd.respond_to?(:increment)
+      statsd.increment(stat, metric_options(options))
+    rescue StandardError => e
+      Datadog::Tracer.log.error("Failed to send increment stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def gauge(stat, value, options = nil)
+      return unless send_stats? && statsd.respond_to?(:gauge)
+      statsd.gauge(stat, value, metric_options(options))
+    rescue StandardError => e
+      Datadog::Tracer.log.error("Failed to send gauge stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def time(stat, options = nil)
+      return yield unless send_stats?
+
+      # Calculate time, send it as a distribution.
+      start = Utils::Time.get_time
+      return yield
+    ensure
+      begin
+        if send_stats? && !start.nil?
+          finished = Utils::Time.get_time
+          distribution(stat, ((finished - start) * 1000), options)
+        end
+      rescue StandardError => e
+        Datadog::Tracer.log.error("Failed to send time stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      end
+    end
+
+    # For defining and adding default options to metrics
+    module Options
+      DEFAULT = {
+        tags: DEFAULT_TAGS = [
+          "#{Ext::Metrics::TAG_LANG}:#{Runtime::Identity.lang}".freeze
+          # "#{Ext::Metrics::TAG_LANG_INTERPRETER}:#{Runtime::Identity.lang_interpreter}".freeze,
+          # "#{Ext::Metrics::TAG_LANG_VERSION}:#{Runtime::Identity.lang_version}".freeze,
+          # "#{Ext::Metrics::TAG_TRACER_VERSION}:#{Runtime::Identity.tracer_version}".freeze
+        ].freeze
+      }.freeze
+
+      def metric_options(options = nil)
+        return default_metric_options if options.nil?
+
+        default_metric_options.merge(options) do |key, old_value, new_value|
+          case key
+          when :tags
+            old_value.dup.concat(new_value).uniq
+          else
+            new_value
+          end
+        end
+      end
+
+      def default_metric_options
+        # Return dupes, so that the constant isn't modified,
+        # and defaults are unfrozen for mutation in Statsd.
+        DEFAULT.dup.tap do |options|
+          options[:tags] = options[:tags].dup
+
+          # Add runtime ID dynamically because it might change during fork.
+          options[:tags] << "#{Ext::Metrics::TAG_RUNTIME_ID}:#{Runtime::Identity.id}".freeze
+        end
+      end
+    end
+
+    # Make available on for both class and instance.
+    include Options
+    extend Options
+  end
+end

data/lib/ddtrace/runtime/class_count.rb

@@ -0,0 +1,17 @@
+module Datadog
+  module Runtime
+    # Retrieves number of classes from runtime
+    module ClassCount
+      module_function
+
+      def value
+        ObjectSpace.count_objects[:T_CLASS]
+      end
+
+      def available?
+        ObjectSpace.respond_to?(:count_objects) \
+          && ObjectSpace.count_objects.key?(:T_CLASS)
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/gc.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Runtime
+    # Retrieves garbage collection statistics
+    module GC
+      module_function
+
+      def stat
+        ::GC.stat
+      end
+
+      def available?
+        defined?(::GC) && ::GC.respond_to?(:stat)
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/identity.rb

@@ -0,0 +1,41 @@
+require 'securerandom'
+require 'ddtrace/ext/runtime'
+
+module Datadog
+  module Runtime
+    # For runtime identity
+    module Identity
+      module_function
+
+      # Retrieves number of classes from runtime
+      def id
+        @pid ||= Process.pid
+        @id ||= SecureRandom.uuid
+
+        # Check if runtime has changed, e.g. forked.
+        if Process.pid != @pid
+          @pid = Process.pid
+          @id = SecureRandom.uuid
+        end
+
+        @id
+      end
+
+      def lang
+        Ext::Runtime::LANG
+      end
+
+      def lang_interpreter
+        Ext::Runtime::LANG_INTERPRETER
+      end
+
+      def lang_version
+        Ext::Runtime::LANG_VERSION
+      end
+
+      def tracer_version
+        Ext::Runtime::TRACER_VERSION
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/metrics.rb

@@ -0,0 +1,94 @@
+require 'ddtrace/ext/runtime'
+
+require 'ddtrace/metrics'
+require 'ddtrace/runtime/class_count'
+require 'ddtrace/runtime/gc'
+require 'ddtrace/runtime/identity'
+require 'ddtrace/runtime/thread_count'
+
+module Datadog
+  module Runtime
+    # For generating runtime metrics
+    class Metrics < Datadog::Metrics
+      def initialize(options = {})
+        super
+
+        # Initialize service list
+        @services = Set.new
+        @service_tags = nil
+      end
+
+      def associate_with_span(span)
+        return if span.nil?
+
+        # Register service as associated with metrics
+        register_service(span.service) unless span.service.nil?
+
+        # Tag span with language and runtime ID for association with metrics
+        span.set_tag(Ext::Runtime::TAG_LANG, Runtime::Identity.lang)
+        span.set_tag(Ext::Runtime::TAG_RUNTIME_ID, Runtime::Identity.id)
+      end
+
+      # Associate service with runtime metrics
+      def register_service(service)
+        return if service.nil?
+
+        service = service.to_s
+
+        unless @services.include?(service)
+          # Add service to list and update services tag
+          services << service
+
+          # Recompile the service tags
+          compile_service_tags!
+        end
+      end
+
+      # Flush all runtime metrics to Statsd client
+      def flush
+        return unless enabled?
+
+        try_flush { gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, ClassCount.value) if ClassCount.available? }
+        try_flush { gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, ThreadCount.value) if ThreadCount.available? }
+        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if GC.available? }
+      end
+
+      def gc_metrics
+        Hash[
+          GC.stat.map do |k, v|
+            ["#{Ext::Runtime::Metrics::METRIC_GC_PREFIX}.#{k}", v]
+          end
+        ]
+      end
+
+      def try_flush
+        yield
+      rescue StandardError => e
+        Datadog::Tracer.log.error("Error while sending runtime metric. Cause: #{e.message}")
+      end
+
+      def default_metric_options
+        # Return dupes, so that the constant isn't modified,
+        # and defaults are unfrozen for mutation in Statsd.
+        super.tap do |options|
+          options[:tags] = options[:tags].dup
+
+          # Add services dynamically because they might change during runtime.
+          options[:tags].concat(service_tags) unless service_tags.nil?
+        end
+      end
+
+      private
+
+      attr_reader \
+        :service_tags,
+        :services
+
+      def compile_service_tags!
+        @service_tags = services.to_a.collect do |service|
+          "#{Ext::Runtime::Metrics::TAG_SERVICE}:#{service}".freeze
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/thread_count.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Runtime
+    # Retrieves number of threads from runtime
+    module ThreadCount
+      module_function
+
+      def value
+        Thread.list.count
+      end
+
+      def available?
+        Thread.respond_to?(:list)
+      end
+    end
+  end
+end

data/lib/ddtrace/utils/time.rb

@@ -0,0 +1,14 @@
+module Datadog
+  module Utils
+    # Common database-related utility functions.
+    module Time
+      PROCESS_TIME_SUPPORTED = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1.0')
+
+      module_function
+
+      def get_time
+        PROCESS_TIME_SUPPORTED ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : ::Time.now.to_f
+      end
+    end
+  end
+end

data/lib/ddtrace/version.rb

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

data/lib/ddtrace/workers.rb

@@ -1,6 +1,7 @@
 require 'time'
 
 require 'ddtrace/buffer'
+require 'ddtrace/runtime/metrics'
 
 module Datadog
   module Workers
@@ -14,19 +15,31 @@ module Datadog
       BACK_OFF_MAX = 5
       SHUTDOWN_TIMEOUT = 1
 
-      attr_reader :trace_buffer, :service_buffer
+      attr_reader \
+        :service_buffer,
+        :trace_buffer
 
-      def initialize(transport, buff_size, trace_task, service_task, interval)
-        @trace_task = trace_task
-        @service_task = service_task
+      def initialize(options = {})
+        @transport = options[:transport]
+
+        # Callbacks
+        @trace_task = options[:on_trace]
+        @service_task = options[:on_service]
+        @runtime_metrics_task = options[:on_runtime_metrics]
+
+        # Intervals
+        interval = options.fetch(:interval, 1)
         @flush_interval = interval
         @back_off = interval
-        @trace_buffer = TraceBuffer.new(buff_size)
-        @service_buffer = TraceBuffer.new(buff_size)
-        @transport = transport
+
+        # Buffers
+        buffer_size = options.fetch(:buffer_size, 100)
+        @trace_buffer = TraceBuffer.new(buffer_size)
+        @service_buffer = TraceBuffer.new(buffer_size)
+
+        # Threading
         @shutdown = ConditionVariable.new
         @mutex = Mutex.new
-
         @worker = nil
         @run = false
       end
@@ -36,9 +49,9 @@ module Datadog
         return true if @trace_buffer.empty?
 
         begin
-          traces = @trace_buffer.pop()
+          traces = @trace_buffer.pop
           traces = Pipeline.process!(traces)
-          @trace_task.call(traces, @transport)
+          @trace_task.call(traces, @transport) unless @trace_task.nil?
         rescue StandardError => e
           # ensures that the thread will not die because of an exception.
           # TODO[manu]: findout the reason and reschedule the send if it's not
@@ -53,7 +66,7 @@ module Datadog
 
         begin
           services = @service_buffer.pop()
-          @service_task.call(services[0], @transport)
+          @service_task.call(services[0], @transport) unless @service_task.nil?
         rescue StandardError => e
           # ensures that the thread will not die because of an exception.
           # TODO[manu]: findout the reason and reschedule the send if it's not
@@ -62,6 +75,12 @@ module Datadog
         end
       end
 
+      def callback_runtime_metrics
+        @runtime_metrics_task.call unless @runtime_metrics_task.nil?
+      rescue StandardError => e
+        Datadog::Tracer.log.error("Error during runtime metrics flush. Cause: #{e}")
+      end
+
       # Start the timer execution.
       def start
         @mutex.synchronize do
@@ -113,6 +132,7 @@ module Datadog
           @back_off = flush_data ? @flush_interval : [@back_off * BACK_OFF_RATIO, BACK_OFF_MAX].min
 
           callback_services
+          callback_runtime_metrics
 
           @mutex.synchronize do
             return if !@run && @trace_buffer.empty? && @service_buffer.empty?

data/lib/ddtrace/writer.rb

@@ -3,15 +3,20 @@ require 'ddtrace/encoding'
 require 'ddtrace/workers'
 
 module Datadog
-  # Traces and services writer that periodically sends data to the trace-agent
+  # Processor that sends traces and metadata to the agent
   class Writer
-    attr_reader :transport, :worker, :priority_sampler
+    attr_reader \
+      :priority_sampler,
+      :runtime_metrics,
+      :transport,
+      :worker
 
     def initialize(options = {})
       # writer and transport parameters
       @buff_size = options.fetch(:buffer_size, 100)
       @flush_interval = options.fetch(:flush_interval, 1)
       transport_options = options.fetch(:transport_options, {})
+
       # priority sampling
       if options[:priority_sampler]
         @priority_sampler = options[:priority_sampler]
@@ -24,6 +29,11 @@ module Datadog
         HTTPTransport.new(transport_options)
       end
 
+      # Runtime metrics
+      @runtime_metrics = options.fetch(:runtime_metrics) do
+        Runtime::Metrics.new
+      end
+
       @services = {}
 
       # handles the thread creation after an eventual fork
@@ -43,11 +53,15 @@ module Datadog
       @pid = Process.pid
       @trace_handler = ->(items, transport) { send_spans(items, transport) }
       @service_handler = ->(items, transport) { send_services(items, transport) }
-      @worker = Datadog::Workers::AsyncTransport.new(@transport,
-                                                     @buff_size,
-                                                     @trace_handler,
-                                                     @service_handler,
-                                                     @flush_interval)
+      @runtime_metrics_handler = -> { send_runtime_metrics }
+      @worker = Datadog::Workers::AsyncTransport.new(
+        transport: @transport,
+        buffer_size: @buff_size,
+        on_trace: @trace_handler,
+        on_service: @service_handler,
+        on_runtime_metrics: @runtime_metrics_handler,
+        interval: @flush_interval
+      )
 
       @worker.start()
     end
@@ -80,6 +94,12 @@ module Datadog
       status
     end
 
+    def send_runtime_metrics
+      return unless Datadog.configuration.runtime_metrics_enabled
+
+      runtime_metrics.flush
+    end
+
     # enqueue the trace for submission to the API
     def write(trace, services)
       # In multiprocess environments, the main process initializes the +Writer+ instance and if
@@ -98,6 +118,9 @@ module Datadog
         end
       end
 
+      # Associate root span with runtime metrics
+      runtime_metrics.associate_with_span(trace.first) unless trace.empty?
+
       @worker.enqueue_trace(trace)
       @worker.enqueue_service(services)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.21.2
+  version: 0.22.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-10 00:00:00.000000000 Z
+date: 2019-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -25,33 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: opentracing
+  name: dogstatsd-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.1
-  type: :runtime
+        version: 3.3.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.1
+        version: 3.3.0
 - !ruby/object:Gem::Dependency
-  name: climate_control
+  name: opentracing
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.4.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.4.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -206,6 +206,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: climate_control
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
@@ -510,10 +524,13 @@ files:
 - lib/ddtrace/ext/distributed.rb
 - lib/ddtrace/ext/errors.rb
 - lib/ddtrace/ext/http.rb
+- lib/ddtrace/ext/metrics.rb
 - lib/ddtrace/ext/net.rb
 - lib/ddtrace/ext/priority.rb
+- lib/ddtrace/ext/runtime.rb
 - lib/ddtrace/ext/sql.rb
 - lib/ddtrace/logger.rb
+- lib/ddtrace/metrics.rb
 - lib/ddtrace/monkey.rb
 - lib/ddtrace/opentracer.rb
 - lib/ddtrace/opentracer/binary_propagator.rb
@@ -542,6 +559,11 @@ files:
 - lib/ddtrace/provider.rb
 - lib/ddtrace/quantization/hash.rb
 - lib/ddtrace/quantization/http.rb
+- lib/ddtrace/runtime/class_count.rb
+- lib/ddtrace/runtime/gc.rb
+- lib/ddtrace/runtime/identity.rb
+- lib/ddtrace/runtime/metrics.rb
+- lib/ddtrace/runtime/thread_count.rb
 - lib/ddtrace/sampler.rb
 - lib/ddtrace/span.rb
 - lib/ddtrace/sync_writer.rb
@@ -549,6 +571,7 @@ files:
 - lib/ddtrace/transport.rb
 - lib/ddtrace/utils.rb
 - lib/ddtrace/utils/database.rb
+- lib/ddtrace/utils/time.rb
 - lib/ddtrace/vendor/active_record/connection_specification.rb
 - lib/ddtrace/version.rb
 - lib/ddtrace/workers.rb
@@ -575,7 +598,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications