canvas_statsd 1.0.8 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf80962c746b4bd54e9a0e57a75764f33b6b35eb
-  data.tar.gz: 733d4b3269e6a8b636451f60aa8b48027b0f7600
+  metadata.gz: 951dbaa395f7d79e76329d841ca6ce9aa8716a07
+  data.tar.gz: 2b9f6679bc1dd954fbe53ddf22fe43febde61380
 SHA512:
-  metadata.gz: 51687134299407eb74454c51b07bf321af1a52908fb353ac131b173f19a3370f25eede3c0dceac2020af07e0d5fec2cb25351e0d0bc83e4086595abbbf5f37ef
-  data.tar.gz: a2d02a7f7bdb17633639de33f99d283f22c21529729a17aff09d6ff0112379f3824948972c27c9de161ab249a068bbf2565c4f400e2b8cf954b4377366699481
+  metadata.gz: 9465805cde29e5584b03fd173fb1b9d08cd21892413c6e1c8a06daa5a6295b45ea32ef8acdcab8a05bb967e8f385b9013e8e98b54dcb9a1922f9d849f6734b8d
+  data.tar.gz: a2c901c2764ff4a5690a6704a0f68c28da6ea13f97b52a5237caaeb3c15ff38fa9d05509fb1a345bce2a0dfc278af3104f64b39d81e91eb0ddd828bcd09abdba

data/lib/canvas_statsd.rb

@@ -1,5 +1,4 @@
 require 'statsd'
-require "aroi" if defined?(ActiveRecord)
 
 module CanvasStatsd
   VALID_SETTINGS = [:host, :port, :namespace, :append_hostname]
@@ -7,59 +6,60 @@ module CanvasStatsd
   class ConfigurationError < StandardError; end
 
   require "canvas_statsd/statsd"
+  require "canvas_statsd/block_stat"
+  require "canvas_statsd/block_tracking"
   require "canvas_statsd/request_stat"
   require "canvas_statsd/counter"
   require "canvas_statsd/sql_tracker"
   require "canvas_statsd/default_tracking"
   require "canvas_statsd/request_logger"
+  require "canvas_statsd/request_tracking"
   require "canvas_statsd/null_logger"
 
-  def self.settings
-    @settings || env_settings
-  end
-
-  def self.settings=(value)
-    @settings = validate_settings(value)
-  end
-
-  def self.validate_settings(value)
-    return nil if value.nil?
-
-    validated = {}
-    value.each do |k,v|
-      if !VALID_SETTINGS.include?(k.to_sym)
-        raise CanvasStatsd::ConfigurationError, "Invalid key: #{k}"
+  class << self
+    def settings
+      @settings || env_settings
+    end
+  
+    def settings=(value)
+      @settings = validate_settings(value)
+    end
+  
+    def validate_settings(value)
+      return nil if value.nil?
+  
+      validated = {}
+      value.each do |k,v|
+        if !VALID_SETTINGS.include?(k.to_sym)
+          raise CanvasStatsd::ConfigurationError, "Invalid key: #{k}"
+        end
+        validated[k.to_sym] = v
       end
-      validated[k.to_sym] = v
+  
+      env_settings.merge(validated)
     end
-
-    env_settings.merge(validated)
-  end
-
-  def self.env_settings(env=ENV)
-    config = {
-      host: env.fetch('CANVAS_STATSD_HOST', nil),
-      port: env.fetch('CANVAS_STATSD_PORT', nil),
-      namespace: env.fetch('CANVAS_STATSD_NAMESPACE', nil),
-      append_hostname: env.fetch('CANVAS_STATSD_APPEND_HOSTNAME', nil),
-    }
-    config.delete_if {|k,v| v.nil?}
-    convert_bool(config, :append_hostname)
-    config[:host] ? config : {}
-  end
-
-  def self.convert_bool(hash, key)
-    value = hash[key]
-    return if value.nil?
-    unless ['true', 'True', 'false', 'False', true, false].include?(value)
-      message = "#{key} must be a boolean, or the string representation of a boolean, got: #{value}"
-      raise CanvasStatsd::ConfigurationError, message
+  
+    def env_settings(env=ENV)
+      config = {
+        host: env.fetch('CANVAS_STATSD_HOST', nil),
+        port: env.fetch('CANVAS_STATSD_PORT', nil),
+        namespace: env.fetch('CANVAS_STATSD_NAMESPACE', nil),
+        append_hostname: env.fetch('CANVAS_STATSD_APPEND_HOSTNAME', nil),
+      }
+      config.delete_if {|k,v| v.nil?}
+      convert_bool(config, :append_hostname)
+      config[:host] ? config : {}
+    end
+  
+    def convert_bool(hash, key)
+      value = hash[key]
+      return if value.nil?
+      unless ['true', 'True', 'false', 'False', true, false].include?(value)
+        message = "#{key} must be a boolean, or the string representation of a boolean, got: #{value}"
+        raise CanvasStatsd::ConfigurationError, message
+      end
+      hash[key] = ['true', 'True', true].include?(value)
     end
-    hash[key] = ['true', 'True', true].include?(value)
-  end
-
-  def self.track_default_metrics options={}
-    CanvasStatsd::DefaultTracking.track_default_metrics options
   end
 
 end

data/lib/canvas_statsd/block_stat.rb

@@ -0,0 +1,37 @@
+module CanvasStatsd
+  class BlockStat
+
+    attr_accessor :stats
+    attr_accessor :common_key
+
+    def initialize(common_key, statsd=CanvasStatsd::Statsd)
+      self.common_key = common_key
+      @statsd = statsd
+      @stats = {}
+    end
+
+    def subtract_exclusives(stats)
+      @exclusives ||= {}
+      stats.each do |(key, value)|
+        @exclusives[key] ||= 0.0
+        @exclusives[key] += value
+      end
+    end
+
+    def exclusive_stats
+      return nil unless @exclusives
+      stats.map { |key, value| [key, value - (@exclusives[key] || 0.0)] }.to_h
+    end
+
+    def report
+      if common_key
+        stats.each do |(key, value)|
+          @statsd.timing("#{common_key}.#{key}", value)
+        end
+        exclusive_stats&.each do |(key, value)|
+          @statsd.timing("#{common_key}.exclusive.#{key}", value)
+        end
+      end
+    end
+  end
+end

data/lib/canvas_statsd/block_tracking.rb

@@ -0,0 +1,47 @@
+require 'benchmark'
+
+module CanvasStatsd
+  class BlockTracking
+    class << self
+      attr_accessor :logger
+
+      def track(key, category: nil, statsd: CanvasStatsd::Statsd, only: nil)
+        cookies = if only
+                    Array(only).map { |name| [name, Counter.counters[name].start] }
+                  else
+                    Counter.counters.map { |(name, counter)| [name, counter.start] }
+                  end
+        block_stat = CanvasStatsd::BlockStat.new(key, statsd)
+        stack(category).push(block_stat) if category
+
+        result = nil
+        elapsed = Benchmark.realtime do
+          result = yield
+        end
+        # to be consistent with ActionPack, measure in milliseconds
+        elapsed *= 1000
+
+        block_stat.stats = cookies.map { |(name, cookie)| [name, Counter.counters[name].finalize_count(cookie)] }.to_h
+        block_stat.stats['total'] = elapsed
+        # we need to make sure to report exclusive timings, even if nobody called us re-entrantly
+        block_stat.subtract_exclusives({}) if category
+        block_stat.report
+        logger.log(block_stat, "STATSD #{key}") if logger
+        # -1 is ourselves; we want to subtract from the block above us
+        stack(category)[-2].subtract_exclusives(block_stat.stats) if category && stack(category)[-2]
+
+        result
+      ensure
+        stack(category).pop if category && stack(category) == block_stat
+      end
+
+      private
+
+      def stack(category)
+        Thread.current[:stats_block_stack] ||= {}
+        Thread.current[:stats_block_stack][category] ||= []
+      end
+    end
+
+  end
+end

data/lib/canvas_statsd/counter.rb

@@ -1,5 +1,14 @@
 module CanvasStatsd
   class Counter
+    class << self
+      def counters
+        @counters ||= {}
+      end
+
+      def register(counter)
+        counters[counter.key] = counter
+      end
+    end
 
     attr_reader :key
     attr_reader :blocked_names
@@ -7,24 +16,24 @@ module CanvasStatsd
     def initialize(key, blocked_names=[])
       @blocked_names = blocked_names
       @key = key
+      @tls_key = "statsd.#{key}"
+      self.class.register(self)
     end
 
     def start
-      Thread.current[key] = 0
+      Thread.current[@tls_key] ||= 0
     end
 
     def track(name)
-      Thread.current[key] += 1 if Thread.current[key] && accepted_name?(name)
+      Thread.current[@tls_key] += 1 if Thread.current[@tls_key] && accepted_name?(name)
     end
 
-    def finalize_count
-      final_count = count
-      Thread.current[key] = 0
-      final_count
+    def finalize_count(cookie)
+      Thread.current[@tls_key] - cookie
     end
 
     def count
-      Thread.current[key]
+      Thread.current[@tls_key]
     end
 
     def accepted_name?(name)

data/lib/canvas_statsd/default_tracking.rb

@@ -1,78 +1,42 @@
+require "active_support"
+
 module CanvasStatsd
   class DefaultTracking
-
-    @ar_counter = CanvasStatsd::Counter.new('ar_counter')
-    @cache_read_counter = CanvasStatsd::Counter.new('cache_read_counter')
-    @sql_tracker = CanvasStatsd::SqlTracker.new(blocked_names: ['SCHEMA'])
-
-    def self.track_default_metrics(options={})
-      options = {sql: true, active_record: true, cache: true, logger: nil}.merge(options)
-      @logger = RequestLogger.new(options[:logger])
-      track_timing
-      track_sql if !!options[:sql]
-      track_active_record if !!options[:active_record]
-      track_cache if !!options[:cache]
-    end
-
-    def self.subscribe type, &block
-      ActiveSupport::Notifications.subscribe type, &block
-    end
-
-    private
-
-    def self.instrument_active_record_creation
-      ::Aroi::Instrumentation.instrument_creation!
-    end
-
-    def self.track_timing
-      subscribe(/start_processing\.action_controller/) {|*args| start_processing(*args)}
-      subscribe(/process_action\.action_controller/) {|*args| finalize_processing(*args)}
-    end
-
     def self.track_sql
-      @tracking_sql = true
-      subscribe(/sql\.active_record/) {|*args| update_sql_count(*args)}
+      return if @sql_tracker
+      @sql_tracker = CanvasStatsd::SqlTracker.new(blocked_names: ['SCHEMA'])
+      ActiveSupport::Notifications.subscribe(/sql\.active_record/) {|*args| update_sql_count(*args)}
     end
 
     def self.track_active_record
-      instrument_active_record_creation
-      @tracking_active_record = true
-      subscribe(/instance\.active_record/) {|*args| update_active_record_count(*args)}
+      return if @ar_counter
+      require 'aroi'
+
+      ::Aroi::Instrumentation.instrument_creation!
+      @ar_counter = CanvasStatsd::Counter.new('active_record')
+      ActiveSupport::Notifications.subscribe(/instance\.active_record/) {|*args| update_active_record_count(*args)}
     end
 
     def self.track_cache
-      @tracking_cache = true
-      subscribe(/cache_read\.active_support/) {|*args| update_cache_read_count(*args)}
-    end
+      return if @cache_read_counter
 
-    def self.start_processing *args
-      @sql_tracker.start
-      @ar_counter.start
-      @cache_read_counter.start
+      @cache_read_counter = CanvasStatsd::Counter.new('cache.read')
+      ActiveSupport::Notifications.subscribe(/cache_read\.active_support/) {|*args| update_cache_read_count(*args)}
     end
 
-    def self.update_sql_count name, start, finish, id, payload
+    private
+
+    def self.update_sql_count(_name, _start, _finish, _id, payload)
       @sql_tracker.track payload.fetch(:name), payload.fetch(:sql)
     end
 
-    def self.update_active_record_count name, start, finish, id, payload
+    def self.update_active_record_count(_name, _start, _finish, _id, payload)
       @ar_counter.track payload.fetch(:name, '')
     end
 
-    def self.update_cache_read_count name, start, finish, id, payload
+    def self.update_cache_read_count(_name, _start, _finish, _id, _payload)
       @cache_read_counter.track "read"
     end
 
-    def self.finalize_processing *args
-      request_stat = CanvasStatsd::RequestStat.new(*args)
-      request_stat.ar_count = @ar_counter.finalize_count if @tracking_active_record
-      request_stat.sql_read_count = @sql_tracker.num_reads if @tracking_sql
-      request_stat.sql_write_count = @sql_tracker.num_writes if @tracking_sql
-      request_stat.sql_cache_count = @sql_tracker.num_caches if @tracking_sql
-      request_stat.cache_read_count = @cache_read_counter.finalize_count if @tracking_cache
-      request_stat.report
-      @logger.log(request_stat)
-    end
-
   end
 end

data/lib/canvas_statsd/request_logger.rb

@@ -1,18 +1,6 @@
 module CanvasStatsd
   class RequestLogger
 
-    VALUES_MAP = {
-        total: :ms,
-        view: :view_runtime,
-        db: :db_runtime,
-        sql_read: :sql_read_count,
-        sql_write: :sql_write_count,
-        sql_cache: :sql_cache_count,
-        active_record: :ar_count,
-        cache_read: :cache_read_count,
-      }.freeze
-
-
     def initialize(logger)
       @logger = logger || CanvasStatsd::NullLogger.new
     end
@@ -24,9 +12,11 @@ module CanvasStatsd
     def build_log_message(request_stat, header=nil)
       header ||= "STATSD"
       message = "[#{header}]"
-      VALUES_MAP.each do |k,v|
-        value = request_stat.respond_to?(v) ? request_stat.send(v) : nil
-        message += " (#{k}: #{"%.2f" % value})" if value
+      request_stat.stats.each do |(name, value)|
+        message += " (#{name.to_s.gsub('.', '_')}: #{"%.2f" % value})"
+      end
+      request_stat.exclusive_stats&.each do |(name, value)|
+        message += " (exclusive_#{name.to_s.gsub('.', '_')}: #{"%.2f" % value})"
       end
       message
     end

data/lib/canvas_statsd/request_stat.rb

@@ -1,33 +1,25 @@
 module CanvasStatsd
-  class RequestStat
-
-    attr_accessor :sql_read_count
-    attr_accessor :sql_write_count
-    attr_accessor :sql_cache_count
-    attr_accessor :ar_count
-    attr_accessor :cache_read_count
-
+  class RequestStat < BlockStat
     def initialize(name, start, finish, id, payload, statsd=CanvasStatsd::Statsd)
+      super(nil, statsd)
       @name = name
       @start = start
       @finish = finish
       @id = id
       @payload = payload
-      @statsd = statsd
+    end
+
+    def common_key
+      common_key = super
+      return common_key if common_key
+      self.common_key = "request.#{controller}.#{action}" if controller && action
     end
 
     def report
-      if controller && action
-        common_key = "request.#{controller}.#{action}"
-        @statsd.timing("#{common_key}.total", ms)
-        @statsd.timing("#{common_key}.view", view_runtime) if view_runtime
-        @statsd.timing("#{common_key}.db", db_runtime) if db_runtime
-        @statsd.timing("#{common_key}.sql.read", sql_read_count) if sql_read_count
-        @statsd.timing("#{common_key}.sql.write", sql_write_count) if sql_write_count
-        @statsd.timing("#{common_key}.sql.cache", sql_cache_count) if sql_cache_count
-        @statsd.timing("#{common_key}.active_record", ar_count) if ar_count
-        @statsd.timing("#{common_key}.cache.read", cache_read_count) if cache_read_count
-      end
+      stats['total'] = total
+      stats['view'] = view_runtime if view_runtime
+      stats['db'] = db_runtime if db_runtime
+      super
     end
 
     def db_runtime
@@ -46,7 +38,7 @@ module CanvasStatsd
       @payload.fetch(:params, {})['action']
     end
 
-    def ms
+    def total
       if (!@finish || !@start)
         return 0
       end

data/lib/canvas_statsd/request_tracking.rb

@@ -0,0 +1,27 @@
+module CanvasStatsd
+  class RequestTracking
+
+    def self.enable(logger: nil)
+      @logger = RequestLogger.new(logger)
+      track_timing
+    end
+
+    private
+
+    def self.track_timing
+      ActiveSupport::Notifications.subscribe(/start_processing\.action_controller/, &method(:start_processing))
+      ActiveSupport::Notifications.subscribe(/process_action\.action_controller/, &method(:finalize_processing))
+    end
+
+    def self.start_processing(*_args)
+      @cookies = Counter.counters.map { |(name, counter)| [name, counter.start] }
+    end
+
+    def self.finalize_processing *args
+      request_stat = CanvasStatsd::RequestStat.new(*args)
+      request_stat.stats = @cookies.map { |(name, cookie)| [name, Counter.counters[name].finalize_count(cookie)] }.to_h
+      request_stat.report
+      @logger.log(request_stat)
+    end
+  end
+end

data/lib/canvas_statsd/sql_tracker.rb

@@ -6,13 +6,13 @@ module CanvasStatsd
     def initialize(opts=nil)
       opts ||= {}
       @blocked_names = opts.fetch(:blocked_names, [])
-      @read_counts = opts.fetch(:read_counter, CanvasStatsd::Counter.new('sql_read_counter'))
-      @write_counts = opts.fetch(:write_counter, CanvasStatsd::Counter.new('sql_write_counter'))
-      @cache_counts = opts.fetch(:cache_counter, CanvasStatsd::Counter.new('sql_cache_counter'))
+      @read_counts = opts.fetch(:read_counter, CanvasStatsd::Counter.new('sql.read'))
+      @write_counts = opts.fetch(:write_counter, CanvasStatsd::Counter.new('sql.write'))
+      @cache_counts = opts.fetch(:cache_counter, CanvasStatsd::Counter.new('sql.cache'))
     end
 
     def start
-      [read_counts, write_counts, cache_counts].each(&:start)
+      [read_counts, write_counts, cache_counts].map(&:start)
     end
 
     def track name, sql
@@ -27,16 +27,12 @@ module CanvasStatsd
       end
     end
 
-    def num_reads
-      read_counts.finalize_count
-    end
-
-    def num_writes
-      write_counts.finalize_count
-    end
-
-    def num_caches
-      cache_counts.finalize_count
+    def finalize_counts(cookies)
+      [
+        read_counts.finalize_count(cookies[0]),
+        write_counts.finalize_count(cookies[1]),
+        cache_counts.finalize_count(cookies[2])
+      ]
     end
 
     private

data/spec/canvas_statsd/block_stat_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe CanvasStatsd::BlockStat do
+  it "track exclusives correctly" do
+    stat = CanvasStatsd::BlockStat.new("key")
+    stat.stats['total'] = 5.0
+    stat.subtract_exclusives("total" => 1.5)
+    stat.subtract_exclusives("total" => 2.1)
+    expect(stat.exclusive_stats).to eql("total" => 1.4)
+  end
+end

data/spec/canvas_statsd/block_tracking_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe CanvasStatsd::BlockTracking do
+  before(:all) do
+    CanvasStatsd::DefaultTracking.track_sql
+  end
+
+  it "works" do
+    statsd = double()
+    allow(statsd).to receive(:timing).with('mykey.total', anything)
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 1)
+
+    CanvasStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read') do
+      ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+    end
+  end
+
+  it "keeps track of exclusive stats too" do
+    statsd = double()
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 2).ordered
+    expect(statsd).to receive(:timing).with('mykey.total', anything).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 2).ordered
+    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything).ordered
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 3).ordered
+    expect(statsd).to receive(:timing).with('mykey.total', anything).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 1).ordered
+    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything).ordered
+
+    CanvasStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: 'sql.read') do
+      ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+      CanvasStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: 'sql.read') do
+        ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+        ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+      end
+    end
+  end
+end

data/spec/canvas_statsd/counter_spec.rb

@@ -22,41 +22,36 @@ describe CanvasStatsd::Counter do
     end
   end
 
-  describe "#start" do
-    it 'should reset count to zero' do
-      subject.start
-      expect(subject.count).to eq 0
-    end
-  end
-
   describe "#track" do
     it 'should increment when given allowed names' do
-      subject.start
+      cookie = subject.start
       subject.track('bar')
       subject.track('baz')
-      expect(subject.count).to eq 2
+      expect(subject.finalize_count(cookie)).to eq 2
     end
 
     it 'should not increment when given a blocked name' do
-      subject.start
+      cookie = subject.start
       subject.track('foo') #shouldn't count as foo is a blocked name
       subject.track('name')
-      expect(subject.count).to eq 1
+      expect(subject.finalize_count(cookie)).to eq 1
     end
   end
 
   describe "#finalize_count" do
     it 'should return the current count' do
-      subject.start
+      cookie = subject.start
       subject.track('bar')
-      expect(subject.finalize_count).to eq 1
+      expect(subject.finalize_count(cookie)).to eq 1
     end
 
-    it 'should reset the current count to 0' do
-      subject.start
+    it 'should not interfere with multiple people using the object' do
+      cookie1 = subject.start
+      subject.track('bar')
+      cookie2 = subject.start
       subject.track('bar')
-      subject.finalize_count
-      expect(subject.count).to eq 0
+      expect(subject.finalize_count(cookie1)).to eq 2
+      expect(subject.finalize_count(cookie2)).to eq 1
     end
   end
 

data/spec/canvas_statsd/request_logger_spec.rb

@@ -9,42 +9,55 @@ describe CanvasStatsd::RequestLogger do
     end
     it 'includes the supplied header' do
       request_stat = double('request_stat')
+      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
+      allow(request_stat).to receive(:stats).and_return({})
       results = @logger.build_log_message(request_stat, 'FOO_STATS')
       expect(results).to eq("[FOO_STATS]")
     end
     it 'falls back to the default header' do
       request_stat = double('request_stat')
+      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
+      allow(request_stat).to receive(:stats).and_return({})
       results = @logger.build_log_message(request_stat)
       expect(results).to eq("[STATSD]")
     end
     it 'includes stats that are available' do
       request_stat = double('request_stat')
-      allow(request_stat).to receive(:ms).and_return(100.21)
-      allow(request_stat).to receive(:ar_count).and_return(24)
+      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
+      allow(request_stat).to receive(:stats).and_return(
+          "total" => 100.21,
+          "active.record" => 24)
       results = @logger.build_log_message(request_stat)
       expect(results).to eq("[STATSD] (total: 100.21) (active_record: 24.00)")
     end
-    it 'doesnt include nil stats' do
+
+    it 'includes exclusive_stats if there are any' do
       request_stat = double('request_stat')
-      allow(request_stat).to receive(:ms).and_return(100.22)
-      allow(request_stat).to receive(:ar_count).and_return(nil)
+      allow(request_stat).to receive(:stats).and_return(
+          "total" => 100.21,
+          "active.record" => 24)
+      allow(request_stat).to receive(:exclusive_stats).and_return(
+          "total" => 54.32,
+          "active.record" => 1)
       results = @logger.build_log_message(request_stat)
-      expect(results).to eq("[STATSD] (total: 100.22)")
+      expect(results).to eq("[STATSD] (total: 100.21) (active_record: 24.00) (exclusive_total: 54.32) (exclusive_active_record: 1.00)")
     end
 
     describe 'decimal precision' do
       it 'forces 2 decimal precision' do
         request_stat = double('request_stat')
-        allow(request_stat).to receive(:ms).and_return(72.1)
+        allow(request_stat).to receive(:stats).and_return(total: 72.1)
+        allow(request_stat).to receive(:exclusive_stats).and_return(nil)
         results = @logger.build_log_message(request_stat)
         expect(results).to eq("[STATSD] (total: 72.10)")
       end
       it 'rounds values to 2 decimals' do
         request_stat = double('request_stat')
-        allow(request_stat).to receive(:ms).and_return(72.1382928)
+        allow(request_stat).to receive(:stats).and_return(total: 72.1382928)
+        allow(request_stat).to receive(:exclusive_stats).and_return(nil)
         results = @logger.build_log_message(request_stat)
         expect(results).to eq("[STATSD] (total: 72.14)")
-        allow(request_stat).to receive(:ms).and_return(72.1348209)
+        allow(request_stat).to receive(:stats).and_return(total: 72.1348209)
         results = @logger.build_log_message(request_stat)
         expect(results).to eq("[STATSD] (total: 72.13)")
       end
@@ -58,6 +71,8 @@ describe CanvasStatsd::RequestLogger do
       logger = CanvasStatsd::RequestLogger.new(std_out_logger)
       expect(std_out_logger).to receive(:info)
       request_stat = double('request_stat')
+      allow(request_stat).to receive(:stats).and_return({})
+      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
       logger.log(request_stat)
     end
     it 'sends info method with build_log_message output if logger exists' do
@@ -65,7 +80,8 @@ describe CanvasStatsd::RequestLogger do
       logger = CanvasStatsd::RequestLogger.new(std_out_logger)
       expect(std_out_logger).to receive(:info).with("[DEFAULT_METRICS] (total: 100.20)")
       request_stat = double('request_stat')
-      allow(request_stat).to receive(:ms).and_return(100.2)
+      allow(request_stat).to receive(:stats).and_return(total: 100.2)
+      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
       logger.log(request_stat, "DEFAULT_METRICS")
     end
   end

data/spec/canvas_statsd/request_stat_spec.rb

@@ -68,18 +68,18 @@ describe CanvasStatsd::RequestStat do
     end
   end
 
-  describe '#ms' do
+  describe '#total' do
     it 'correctly calcuates milliseconds from start, finish' do
       rs = create_subject({params: {}})
       # start and finish are in seconds
-      expect(rs.ms).to eq 1000
+      expect(rs.total).to eq 1000
     end
 
     it 'defaults to zero if either start or finish are nil' do
       rs = CanvasStatsd::RequestStat.new('name', nil, 1001, 1111, {params: {}})
-      expect(rs.ms).to eq 0
+      expect(rs.total).to eq 0
       rs = CanvasStatsd::RequestStat.new('name', 1, nil, 1111, {params: {}})
-      expect(rs.ms).to eq 0
+      expect(rs.total).to eq 0
     end
   end
 
@@ -142,7 +142,7 @@ describe CanvasStatsd::RequestStat do
           }
         }
         @rs = create_subject(payload, @statsd)
-        @rs.cache_read_count = 25
+        @rs.stats['cache.read'] = 25
         expect(@statsd).to receive(:timing).with('request.foo.index.cache.read', 25)
       end
 
@@ -155,26 +155,11 @@ describe CanvasStatsd::RequestStat do
       end
 
       it 'sends sql_read_count when present' do
-        @rs.sql_read_count = 10
+        @rs.stats['sql.read'] = 10
         allow(@statsd).to receive(:timing).with('request.foo.index.total', 1000)
         expect(@statsd).to receive(:timing).with('request.foo.index.sql.read', 10)
         @rs.report
       end
-
-      it 'sends sql_read_count when present' do
-        @rs.sql_write_count = 3
-        allow(@statsd).to receive(:timing).with('request.foo.index.total', 1000)
-        expect(@statsd).to receive(:timing).with('request.foo.index.sql.write', 3)
-        @rs.report
-      end
-
-      it 'sends sql_cache_count when present' do
-        @rs.sql_cache_count = 1
-        allow(@statsd).to receive(:timing).with('request.foo.index.total', 1000)
-        expect(@statsd).to receive(:timing).with('request.foo.index.sql.cache', 1)
-        @rs.report
-      end
-
     end
 
   end

data/spec/canvas_statsd/request_tracking_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe CanvasStatsd::RequestTracking do
+
+  describe '#enable' do
+    it 'should delegate log messages to the optional logger' do
+      log_double = double()
+      expect(log_double).to receive(:info)
+      CanvasStatsd::RequestTracking.enable logger: log_double
+      CanvasStatsd::RequestTracking.start_processing
+      CanvasStatsd::RequestTracking.finalize_processing('name', 1000, 10001, 1234, {})
+    end
+  end
+end

data/spec/canvas_statsd/sql_tracker_spec.rb

@@ -8,48 +8,67 @@ module CanvasStatsd
         subject = SqlTracker.new
         subject.start
         subject.track 'CACHE', 'SELECT * FROM some_table'
-        subject.start
-        expect(subject.num_caches).to eq(0)
-        expect(subject.num_reads).to eq(0)
-        expect(subject.num_writes).to eq(0)
+        cookies = subject.start
+        expect(subject.finalize_counts(cookies)).to eq([0, 0, 0])
       end
     end
 
     describe '#track' do
       before :each do
         @subject = SqlTracker.new
-        @subject.start
+        @cookies = @subject.start
+      end
+
+      def finish
+        if @num_reads.nil?
+          @num_reads, @num_writes, @num_caches = @subject.finalize_counts(@cookies)
+        end
+      end
+
+      def num_reads
+        finish
+        @num_reads
+      end
+
+      def num_writes
+        finish
+        @num_writes
+      end
+
+      def num_caches
+        finish
+        @num_caches
       end
 
       it 'considers CACHE above all' do
         @subject.track 'CACHE', 'SELECT * FROM some_table'
-        expect(@subject.num_caches).to eq(1)
-        expect(@subject.num_reads).to eq(0)
+        expect(num_caches).to eq(1)
+        expect(num_reads).to eq(0)
       end
 
       it 'marks as read when select is in the first 15 chars of the sql' do
         @subject.track 'LOAD', '  SELECT "context_external_tools".* FROM'
-        expect(@subject.num_reads).to eq(1)
-        expect(@subject.num_writes).to eq(0)
+        expect(num_reads).to eq(1)
+        expect(num_writes).to eq(0)
       end
 
       it 'marks as read with no select, but a LOAD name' do
         @subject.track 'LOAD', 'WITH RECURSIVE t AS'
-        expect(@subject.num_reads).to eq(1)
-        expect(@subject.num_writes).to eq(0)
+        expect(num_reads).to eq(1)
+        expect(num_writes).to eq(0)
       end
 
       it 'doesnt track names set as blocked' do
         tracker = SqlTracker.new(blocked_names: ['SCHEMA'])
-        tracker.start
+        cookies = tracker.start
         tracker.track 'SCHEMA', 'SELECT * FROM some_table'
-        expect(tracker.num_reads).to eq(0)
+        expect(tracker.finalize_counts(cookies)[0]).to eq(0)
       end
 
       it 'doesnt track nil names or sql values' do
         @subject.track nil, 'SELECT *'
         @subject.track 'CACHE', nil
-        expect(@subject.num_reads).to eq(0)
+        expect(num_reads).to eq(0)
       end
 
       it 'passes full sql to counter.track calls for reads' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canvas_statsd
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 2.0.0
 platform: ruby
 authors:
 - Nick Cloward
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-30 00:00:00.000000000 Z
+date: 2017-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: statsd-ruby
@@ -53,6 +53,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -90,19 +104,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/canvas_statsd.rb
+- lib/canvas_statsd/block_stat.rb
+- lib/canvas_statsd/block_tracking.rb
 - lib/canvas_statsd/counter.rb
 - lib/canvas_statsd/default_tracking.rb
 - lib/canvas_statsd/null_logger.rb
 - lib/canvas_statsd/request_logger.rb
 - lib/canvas_statsd/request_stat.rb
+- lib/canvas_statsd/request_tracking.rb
 - lib/canvas_statsd/sql_tracker.rb
 - lib/canvas_statsd/statsd.rb
+- spec/canvas_statsd/block_stat_spec.rb
+- spec/canvas_statsd/block_tracking_spec.rb
 - spec/canvas_statsd/canvas_statsd_spec.rb
 - spec/canvas_statsd/counter_spec.rb
-- spec/canvas_statsd/default_tracking_spec.rb
 - spec/canvas_statsd/null_logger_spec.rb
 - spec/canvas_statsd/request_logger_spec.rb
 - spec/canvas_statsd/request_stat_spec.rb
+- spec/canvas_statsd/request_tracking_spec.rb
 - spec/canvas_statsd/sql_tracker_spec.rb
 - spec/canvas_statsd/statsd_spec.rb
 - spec/spec_helper.rb
@@ -128,17 +147,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.7
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Statsd for Canvas
 test_files:
+- spec/canvas_statsd/block_stat_spec.rb
+- spec/canvas_statsd/block_tracking_spec.rb
 - spec/canvas_statsd/canvas_statsd_spec.rb
 - spec/canvas_statsd/counter_spec.rb
-- spec/canvas_statsd/default_tracking_spec.rb
 - spec/canvas_statsd/null_logger_spec.rb
 - spec/canvas_statsd/request_logger_spec.rb
 - spec/canvas_statsd/request_stat_spec.rb
+- spec/canvas_statsd/request_tracking_spec.rb
 - spec/canvas_statsd/sql_tracker_spec.rb
 - spec/canvas_statsd/statsd_spec.rb
 - spec/spec_helper.rb

data/spec/canvas_statsd/default_tracking_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'aroi' # ensure aroi is loaded (its only conditionally loaded by default)
-
-describe CanvasStatsd::DefaultTracking do
-
-  describe '#track_default_metrics' do
-    it 'should track timing, sql, and active_record by default' do
-      expect(CanvasStatsd::DefaultTracking).to receive(:track_timing)
-      expect(CanvasStatsd::DefaultTracking).to receive(:track_sql)
-      expect(CanvasStatsd::DefaultTracking).to receive(:track_active_record)
-      CanvasStatsd::DefaultTracking.track_default_metrics
-    end
-
-    it 'should not track sql when sql: false option' do
-      expect(CanvasStatsd::DefaultTracking).not_to receive(:track_sql)
-      CanvasStatsd::DefaultTracking.track_default_metrics sql: false
-    end
-
-    it 'should not track active_record when active_record: false option' do
-      expect(CanvasStatsd::DefaultTracking).not_to receive(:track_active_record)
-      CanvasStatsd::DefaultTracking.track_default_metrics active_record: false
-    end
-
-    it 'should not track cache when cache: false option' do
-      expect(CanvasStatsd::DefaultTracking).not_to receive(:track_cache)
-      CanvasStatsd::DefaultTracking.track_default_metrics cache: false
-    end
-
-    it 'should delegate log messages to the optional logger' do
-      log_double = double()
-      expect(log_double).to receive(:info)
-      CanvasStatsd::DefaultTracking.track_default_metrics logger: log_double
-      CanvasStatsd::DefaultTracking.finalize_processing('name', 1000, 10001, 1234, {})
-    end
-  end
-
-  describe '#track_active_record' do
-    it 'should turn on active record instrumentation' do
-      expect(CanvasStatsd::DefaultTracking).to receive(:instrument_active_record_creation)
-      CanvasStatsd::DefaultTracking.send(:track_active_record)
-    end
-  end
-
-  describe '#subscribe' do
-    it 'should subscribe via ActiveSupport::Notifications' do
-      target = double()
-      CanvasStatsd::DefaultTracking.subscribe(/test\.notification/) {|*args| target.callback(*args)}
-      expect(target).to receive(:callback)
-      ActiveSupport::Notifications.instrument('test.notification') {}
-    end
-  end
-
-end