instrument_all_the_things 1.0.4

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "instrument_all_the_things"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/instrument_all_the_things.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'instrument_all_the_things/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'instrument_all_the_things'
+  spec.version       = InstrumentAllTheThings::VERSION
+  spec.authors       = ['Brian Malinconico']
+  spec.email         = ['bmalinconico@terminus.com']
+
+  spec.summary       = 'Make instrumentation with DataDog easy peasy'
+  spec.description   = 'Wrappers to make instrumentation of methods easy and pleasant to read'
+  spec.homepage      = 'https://github.com/GetTerminus/instrument-all-the-things'
+
+  spec.metadata['allowed_push_host'] = "https://www.rubygems.org"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/GetTerminus/instrument-all-the-things'
+  # spec.metadata['changelog_uri'] = 'http://google.com'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ddtrace'
+  spec.add_dependency 'dogstatsd-ruby'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'benchmark-ips'
+end

data/lib/instrument_all_the_things.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'ddtrace'
+
+require 'instrument_all_the_things/version'
+
+require_relative './instrument_all_the_things/helpers'
+require_relative './instrument_all_the_things/clients/stat_reporter/datadog'
+
+module InstrumentAllTheThings
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :stat_namespace
+    attr_writer :logger, :stat_reporter, :tracer
+
+    def logger
+      return @logger if defined?(@logger)
+
+      @logger ||= if defined?(Rails)
+                    Rails.logger
+                  elsif defined?(App) && App.respond_to?(:logger)
+                    App.logger
+                  else
+                    require 'logger'
+                    Logger.new(STDOUT)
+                  end
+    end
+
+    def stat_reporter
+      return @stat_reporter if defined?(@stat_reporter)
+
+      @stat_reporter ||= Clients::StatReporter::DataDog.new(
+        ENV.fetch('DATADOG_HOST', 'localhost'),
+        ENV.fetch('DATADOG_PORT', 8125),
+        namespace: stat_namespace,
+      )
+    end
+
+    def tracer
+      return @tracer if defined?(@tracer)
+
+      @tracer ||= Datadog.tracer
+    end
+
+    %i[
+      increment
+      decrement
+      count
+      gauge
+      set
+      histogram
+      distribution
+      timing
+      time
+    ].each do |method_name|
+      define_method(method_name) do |*args, **kwargs, &blk|
+        return unless stat_reporter
+
+        stat_reporter.public_send(method_name, *args, **kwargs, &blk)
+      end
+    end
+  end
+
+  def self.included(other)
+    other.include(Helpers)
+  end
+end
+
+IATT = InstrumentAllTheThings unless defined?(IATT)

data/lib/instrument_all_the_things/clients/stat_reporter/datadog.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'datadog/statsd'
+
+module InstrumentAllTheThings
+  module Clients
+    module StatReporter
+      class DataDog < Datadog::Statsd
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/clients/tracer/blackhole.rb

@@ -0,0 +1,22 @@
+module InstrumentAllTheThings
+  module Clients
+    class Blackhole
+      class Span
+        def initialize
+        end
+
+        def set_tag(name, value)
+        end
+      end
+
+
+      def initialize
+        reset!
+      end
+
+      def trace(name, options)
+        yield Span.new
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/context.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module InstrumentAllTheThings
+  Context = Struct.new(:method_name, :instance, :tags, keyword_init: true) do
+    def stats_name(klass_or_instance)
+      @stats_name ||= [
+        class_name(klass_or_instance),
+        (instance ? 'instance' : 'class') + '_methods',
+        method_name,
+      ].join('.')
+    end
+
+    def trace_name(klass_or_instance)
+      @trace_name ||= "#{class_name(klass_or_instance)}#{instance ? '.' : '#'}#{method_name}"
+    end
+
+    private
+
+    def class_name(klass_or_instance)
+      klass_or_instance.is_a?(Class) ? klass_or_instance.to_s : klass_or_instance
+    end
+  end
+end

data/lib/instrument_all_the_things/helpers.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative './method_proxy'
+require_relative './context'
+
+module InstrumentAllTheThings
+  module Helpers
+    module ClassMethods
+      def instrument(**kwargs)
+        @last_settings = kwargs
+      end
+
+      def _conscript_last_iatt_settings
+        @last_settings.tap { @last_settings = nil }
+      end
+
+      def singleton_method_added(method_name)
+        settings = _conscript_last_iatt_settings
+
+        return unless settings
+
+        settings[:context] = Context.new(
+          method_name: method_name,
+          instance: false
+        )
+
+        InstrumentAllTheThings::MethodProxy
+          .for_class(singleton_class)
+          .wrap_implementation(method_name, settings)
+        super
+      end
+
+      def method_added(method_name)
+        settings = _conscript_last_iatt_settings
+
+        return unless settings
+
+        settings[:context] = Context.new(
+          method_name: method_name,
+          instance: true
+        )
+
+        InstrumentAllTheThings::MethodProxy
+          .for_class(self)
+          .wrap_implementation(method_name, settings)
+
+        super
+      end
+    end
+
+    def self.included(other_class)
+      other_class.extend(ClassMethods)
+    end
+  end
+end

data/lib/instrument_all_the_things/instrumentors/all.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative './tracing'
+require_relative './error_logging'
+require_relative './gc_stats'
+require_relative './execution_count_and_timing'

data/lib/instrument_all_the_things/instrumentors/error_logging.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative './tracing'
+require_relative './error_logging'
+
+module InstrumentAllTheThings
+  module Instrumentors
+    DEFAULT_ERROR_LOGGING_OPTIONS = {
+      exclude_bundle_path: true,
+      rescue_class: StandardError,
+    }.freeze
+
+    ERROR_LOGGER = lambda do |exception, backtrace_cleaner|
+    end
+
+    ERROR_LOGGING_WRAPPER = lambda do |opts, context|
+      opts = if opts == true
+               DEFAULT_ERROR_LOGGING_OPTIONS
+             else
+               DEFAULT_ERROR_LOGGING_OPTIONS.merge(opts)
+             end
+
+      backtrace_cleaner = if opts[:exclude_bundle_path] && defined?(Bundler)
+                            bundle_path = Bundler.bundle_path.to_s
+                            ->(trace) { trace.reject { |p| p.start_with?(bundle_path) } }
+                          else
+                            ->(trace) { trace }
+                          end
+
+      lambda do |klass, next_blk, actual_code|
+        next_blk.call(klass, actual_code)
+      rescue opts[:rescue_class] => e
+        raise if e.instance_variable_get(:@_logged_by_iatt)
+
+        e.instance_variable_set(:@_logged_by_iatt, true)
+
+        InstrumentAllTheThings.logger&.error <<~ERROR
+          An error occurred in #{context.trace_name(klass)}
+
+          #{e.message}
+          #{backtrace_cleaner.call(e.backtrace || []).join("\n")}
+        ERROR
+
+        raise
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/instrumentors/execution_count_and_timing.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module InstrumentAllTheThings
+  module Instrumentors
+    DEFAULT_EXECUTION_COUNT_AND_TIMING_OPTIONS = {}.freeze
+
+    EXECUTION_COUNT_AND_TIMING_WRAPPER = proc do |_opts, context|
+      proc do |klass, next_blk, actual_code|
+        context.tags ||= []
+
+        InstrumentAllTheThings.increment("#{context.stats_name(klass)}.executed", { tags: context.tags })
+        InstrumentAllTheThings.time("#{context.stats_name(klass)}.duration", { tags: context.tags }) do
+          next_blk.call(klass, actual_code)
+        end
+      rescue StandardError
+        InstrumentAllTheThings.increment("#{context.stats_name(klass)}.errored", { tags: context.tags })
+        raise
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/instrumentors/gc_stats.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module InstrumentAllTheThings
+  module Instrumentors
+    DEFAULT_GC_STATS_OPTIONS = {
+      diffed_stats: %i[
+        total_allocated_pages
+        total_allocated_objects
+        count
+      ].freeze
+    }.freeze
+
+    # This is to make it easier to spec since other
+    # gems may call this
+    GC_STAT_GETTER = -> { GC.stat }
+
+    GC_STATS_WRAPPER = lambda do |opts, context|
+      opts = if opts == true
+               DEFAULT_GC_STATS_OPTIONS
+             else
+               DEFAULT_GC_STATS_OPTIONS.merge(opts)
+            end
+
+      report_value = proc do |klass, stat_name, value|
+        InstrumentAllTheThings.stat_reporter.histogram(
+          context.stats_name(klass) + ".#{stat_name}_change",
+          value
+        )
+      end
+
+      lambda do |klass, next_blk, actual_code|
+        starting_values = GC_STAT_GETTER.call.slice(*opts[:diffed_stats])
+        next_blk.call(klass, actual_code).tap do
+          new_values = GC_STAT_GETTER.call.slice(*opts[:diffed_stats])
+
+          diff = new_values.merge(starting_values) do |_, new_value, starting_value|
+            new_value - starting_value
+          end
+
+          if (span = InstrumentAllTheThings.tracer.active_span)
+            span.set_tag('gc_stats', diff)
+          end
+
+          diff.each { |s, v| report_value.call(klass, s, v) }
+        end
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/instrumentors/tracing.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module InstrumentAllTheThings
+  module Instrumentors
+    DEFAULT_TRACE_OPTIONS = {
+      service: '',
+      span_type: '',
+      tags: {},
+      span_name: 'method.execution'
+    }.freeze
+
+    TRACE_WRAPPER = proc do |opts, context|
+      opts = if opts == true
+               DEFAULT_TRACE_OPTIONS
+             else
+               DEFAULT_TRACE_OPTIONS.merge(opts)
+             end
+
+      proc do |klass, next_blk, actual_code|
+        InstrumentAllTheThings.tracer.trace(
+          opts[:span_name],
+          tags: context[:tags] || {},
+          service: opts[:service],
+          resource: opts[:resource] || context.trace_name(klass),
+          span_type: opts[:span_type]
+        ) { next_blk.call(klass, actual_code) }
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/method_instrumentor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative './instrumentors/all'
+
+module InstrumentAllTheThings
+  class MethodInstrumentor
+    WRAPPERS = {
+      # Note that the order of these hash keys are applied top to bottom, with the first inserted key
+      # being the inner most wrapper
+      gc_stats: Instrumentors::GC_STATS_WRAPPER,
+      error_logging: Instrumentors::ERROR_LOGGING_WRAPPER,
+      execution_counts_and_timing: Instrumentors::EXECUTION_COUNT_AND_TIMING_WRAPPER,
+      trace: Instrumentors::TRACE_WRAPPER,
+    }.freeze
+
+    DEFAULT_OPTIONS = {
+      trace: true,
+      gc_stats: true,
+      error_logging: true,
+      execution_counts_and_timing: true
+    }.freeze
+
+    attr_accessor :options, :instrumentor
+
+    def initialize(options)
+      self.options = DEFAULT_OPTIONS.merge(options)
+
+      build_instrumentor
+
+      freeze
+    end
+
+    def build_instrumentor
+      procs = WRAPPERS.collect do |type, builder|
+        next unless options[type]
+
+        builder.call(options[type], options[:context])
+      end.compact
+
+      self.instrumentor = combine_procs(procs)
+    end
+
+    def invoke(klass:, &blk)
+      instrumentor.call(klass, blk)
+    end
+
+    private
+
+    def combine_procs(procs)
+      # I know it's crazy, but this wraps procs which take "Next Block"
+      # and "Final Block"
+      procs.inject(->(_, f) { f.call }) do |next_blk, current_blk|
+        proc { |k, final| current_blk.call(k, next_blk, final) }
+      end
+    end
+  end
+end