instrument_all_the_things 0.9.0.alpha

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, 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)
+
+        IATT.logger&.error("An error occurred in #{context.trace_name(klass)}")
+        IATT.logger&.error(e.message)
+
+        callstack = backtrace_cleaner.call(e.backtrace || [])
+
+        IATT.logger&.error(callstack.join("\n"))
+
+        raise
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/instrumentors/execution_count_and_timing.rb

@@ -0,0 +1,20 @@
+# 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|
+        InstrumentAllTheThings.increment("#{context.stats_name(klass)}.executed")
+
+        InstrumentAllTheThings.time("#{context.stats_name(klass)}.duration") do
+          next_blk.call(klass, actual_code)
+        end
+      rescue
+        InstrumentAllTheThings.increment("#{context.stats_name(klass)}.errored")
+        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|
+        IATT.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 = IATT.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: opts[: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,54 @@
+# frozen_string_literal: true
+
+require_relative './instrumentors/all'
+
+module InstrumentAllTheThings
+  class MethodInstrumentor
+    WAPPERS = {
+      trace: Instrumentors::TRACE_WRAPPER,
+      error_logging: Instrumentors::ERROR_LOGGING_WRAPPER,
+      gc_stats: Instrumentors::GC_STATS_WRAPPER,
+      execution_counts_and_timing: Instrumentors::EXECUTION_COUNT_AND_TIMING_WRAPPER,
+    }.freeze
+
+    DEFAULT_OPTIONS = {
+      trace: true,
+      gc_stats: true,
+      error_logging: true,
+    }.freeze
+
+    attr_accessor :options, :instrumentor
+
+    def initialize(options)
+      self.options = DEFAULT_OPTIONS.merge(options)
+
+      build_instrumentor
+
+      freeze
+    end
+
+    def build_instrumentor
+      procs = WAPPERS.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

data/lib/instrument_all_the_things/method_proxy.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative './method_instrumentor'
+
+module InstrumentAllTheThings
+  module MethodProxy
+    def self.for_class(klass)
+      find_for_class(klass) || install_on_class(klass)
+    end
+
+    def self.find_for_class(klass)
+      klass.ancestors.detect do |a|
+        a.is_a?(Instrumentor) &&
+          a._iatt_built_for == klass
+      end
+    end
+
+    def self.install_on_class(klass)
+      construct_for_class(klass).tap do |m|
+        klass.prepend(m)
+      end
+    end
+
+    def self.construct_for_class(klass)
+      Module.new do
+        extend Instrumentor
+      end.tap { |m| m._iatt_built_for = klass }
+    end
+
+    module Instrumentor
+      def inspect
+        "InstrumentAllTheThings::#{@_iatt_built_for}Proxy"
+      end
+
+      def _iatt_built_for
+        @_iatt_built_for
+      end
+
+      def _iatt_built_for=(val)
+        @_iatt_built_for = val
+      end
+
+      def wrap_implementation(method_name, settings)
+        wrap = MethodInstrumentor.new(**settings)
+
+        define_method(method_name) do |*args, **kwargs, &blk|
+          wrap.invoke(klass: is_a?(Class) ? self : self.class) do
+            super(*args, **kwargs, &blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/testing/rspec_matchers.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module InstrumentAllTheThings
+  module Testing
+    module RSpecMatchers
+      def histogram_value(counter_name)
+        stats = IATT.stat_reporter.emitted_values[:histogram][counter_name]
+        stats.inject(0){|l, n| l + n[:args][0] }
+      end
+
+      def distribution_values(distribution_name, with_tags: nil)
+        stats = IATT.stat_reporter.emitted_values[:distribution][distribution_name]
+
+        if with_tags && !stats.empty?
+          stats = stats.select do |s|
+            with_tags.all?{|t| s[:tags].include?(t) }
+          end
+        end
+
+        stats&.map{|i| i[:args] }&.map(&:first) || []
+      end
+
+      def histogram_values(histogram_name, with_tags: nil)
+        stats = IATT.stat_reporter.emitted_values[:histogram][histogram_name]
+
+        if with_tags && !stats.empty?
+          stats = stats.select do |s|
+            with_tags.all?{|t| s[:tags].include?(t) }
+          end
+        end
+
+        stats&.map{|i| i[:args] }&.map(&:first) || []
+      end
+
+      def timing_values(timing_name, with_tags: nil)
+        stats = IATT.stat_reporter.emitted_values[:timing][timing_name]
+
+        if with_tags && !stats.empty?
+          stats = stats.select do |s|
+            with_tags.all?{|t| s[:tags].include?(t) }
+          end
+        end
+
+        stats&.map{|i| i[:args] }&.map(&:first) || []
+      end
+
+      def set_value(counter_name, with_tags: nil)
+        stats = IATT.stat_reporter.emitted_values[:set][counter_name]
+
+        if with_tags && !stats.empty?
+          stats = stats.select do |s|
+            with_tags.all?{|t| s[:tags].include?(t) }
+          end
+        end
+
+        data = stats&.map{|i| i[:args] }&.map(&:first)
+        data ? data.uniq.length : 0
+      end
+
+      def gauge_value(counter_name, with_tags: nil)
+        stats = IATT.stat_reporter.emitted_values[:gauge][counter_name]
+
+        if with_tags && !stats.empty?
+          stats = stats.select do |s|
+            with_tags.all?{|t| s[:tags].include?(t) }
+          end
+        end
+        stats.last&.fetch(:args)&.first
+      end
+
+      def counter_value(counter_name, with_tags: nil)
+        stats = IATT.stat_reporter.emitted_values[:count][counter_name]
+        if with_tags && !stats.empty?
+          stats = stats.select do |s|
+            with_tags.all?{|t| s[:tags].include?(t) }
+          end
+        end
+        stats.inject(0){|l, n| l + n[:args][0] }
+      end
+
+      def flush_traces
+        Datadog.tracer&.writer&.worker&.flush_data
+      end
+
+      def emitted_spans(filtered_by: nil)
+        sleep 0.01
+        traces = IATT::Testing::TraceTracker.tracker.traces.map(&:dup)
+        if filtered_by
+          filtered_by.transform_keys!(&:to_s)
+          traces.select! { |t| filtered_by < t }
+        end
+
+        traces
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/testing/stat_tracker.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'datadog/statsd'
+
+module InstrumentAllTheThings
+  module Testing
+    class StatTracker < Clients::StatReporter::DataDog
+      attr_reader :emitted_values
+      %i[
+      count
+      distribution
+      gauge
+      histogram
+      set
+      time
+      timing
+      ].each do |meth|
+        define_method(meth) do |*args, **kwargs, &blk|
+          @emitted_values[meth][args[0]] << {
+            args: args[1..-1],
+            tags: kwargs.fetch(:tags, []),
+            kwargs: kwargs,
+          }
+
+          super(*args, **kwargs, &blk)
+        end
+      end
+
+      def initialize(*args, **kwargs, &blk)
+        super
+        reset!
+      end
+
+      def reset!
+        @emitted_values = Hash.new do |h, k|
+          h[k] = Hash.new do |h2, k2|
+            h2[k2] = []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/testing/trace_tracker.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module InstrumentAllTheThings
+  module Testing
+    class TraceTracker
+      attr_reader :traces
+
+      def self.tracker
+        @tracker ||= new
+      end
+
+      def initialize
+        reset!
+      end
+
+      def reset!
+        @traces = []
+      end
+
+      def <<(val)
+        @traces = @traces.concat(MessagePack.load(val[:body]).flatten)
+      end
+    end
+  end
+end

data/lib/instrument_all_the_things/version.rb

@@ -0,0 +1,3 @@
+module InstrumentAllTheThings
+  VERSION = "0.9.0.alpha"
+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