canvas_statsd 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 13ba02ddc541f1ef3eebb7aee35f60022eea1e24
+  data.tar.gz: 55456a369e6654ca2320832c9478971644107774
+SHA512:
+  metadata.gz: 6b5af0a665e04b9b1979c65fbbb65be875e5e5fa12aec4fbf7dfa0f4f4cc655ea8514f20d88369078204450efc5cf247a6025cf7275be63f05709d5839c13113
+  data.tar.gz: dd77f76a3c1be35b3c0e9af4cee153e399c70d98331328c31d4a0557191578dd3d1d35d698e3adbaabd95b9418f0cb619baf1677b28affb81e0fb1582443affb

data/lib/canvas_statsd.rb

@@ -0,0 +1,37 @@
+require 'statsd'
+require "aroi"
+
+module CanvasStatsd
+
+  require "canvas_statsd/statsd"
+  require "canvas_statsd/request_stat"
+  require "canvas_statsd/counter"
+  require "canvas_statsd/sql_tracker"
+  require "canvas_statsd/default_tracking"
+
+  def self.settings
+    @settings || env_settings
+  end
+
+  def self.settings=(value)
+    @settings = value
+  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?}
+    config[:append_hostname] = false if config[:append_hostname] == 'false';
+    config[:append_hostname] = true if config[:append_hostname] == 'true';
+    config[:host] ? config : {}
+  end
+
+  def self.track_default_metrics options={}
+    CanvasStatsd::DefaultTracking.track_default_metrics options
+  end
+
+end

data/lib/canvas_statsd/counter.rb

@@ -0,0 +1,35 @@
+module CanvasStatsd
+  class Counter
+
+    attr_reader :key
+    attr_reader :blocked_names
+
+    def initialize(key, blocked_names=[])
+      @blocked_names = blocked_names
+      @key = key
+    end
+
+    def start
+      Thread.current[key] = 0
+    end
+
+    def track(name)
+      Thread.current[key] += 1 if Thread.current[key] && accepted_name?(name)
+    end
+
+    def finalize_count
+      final_count = count
+      Thread.current[key] = 0
+      final_count
+    end
+
+    def count
+      Thread.current[key]
+    end
+
+    def accepted_name?(name)
+      !blocked_names.include?(name)
+    end
+
+  end
+end

data/lib/canvas_statsd/default_tracking.rb

@@ -0,0 +1,63 @@
+module CanvasStatsd
+  class DefaultTracking
+
+    @ar_counter = CanvasStatsd::Counter.new('ar_counter')
+    @sql_tracker = CanvasStatsd::SqlTracker.new(blocked_names: ['SCHEMA'])
+
+    def self.track_default_metrics(options={})
+      options = {sql: true, active_record: true}.merge(options)
+      track_timing
+      track_sql if !!options[:sql]
+      track_active_record if !!options[:active_record]
+    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)}
+    end
+
+    def self.track_active_record
+      instrument_active_record_creation
+      @tracking_active_record = true
+      subscribe(/instance.active_record/) {|*args| update_active_record_count(*args)}
+    end
+
+    def self.start_processing *args
+      @sql_tracker.start
+      @ar_counter.start
+    end
+
+    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
+      @ar_counter.track payload.fetch(:name, '')
+    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.report
+    end
+
+  end
+end

data/lib/canvas_statsd/request_stat.rb

@@ -0,0 +1,55 @@
+module CanvasStatsd
+  class RequestStat
+
+    attr_accessor :sql_read_count
+    attr_accessor :sql_write_count
+    attr_accessor :sql_cache_count
+    attr_accessor :ar_count
+
+    def initialize(name, start, finish, id, payload, statsd=CanvasStatsd::Statsd)
+      @name = name
+      @start = start
+      @finish = finish
+      @id = id
+      @payload = payload
+      @statsd = statsd
+    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
+      end
+    end
+
+    def db_runtime
+      @payload.fetch(:db_runtime, nil)
+    end
+
+    def view_runtime
+      @payload.fetch(:view_runtime, nil)
+    end
+
+    def controller
+      @payload.fetch(:params, {})['controller']
+    end
+
+    def action
+      @payload.fetch(:params, {})['action']
+    end
+
+    def ms
+      if (!@finish || !@start)
+        return 0
+      end
+      (@finish - @start) * 1000
+    end
+
+  end
+end

data/lib/canvas_statsd/sql_tracker.rb

@@ -0,0 +1,54 @@
+module CanvasStatsd
+  class SqlTracker
+
+    attr_reader :blocked_names, :read_counts, :write_counts, :cache_counts
+
+    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'))
+    end
+
+    def start
+      [read_counts, write_counts, cache_counts].each(&:start)
+    end
+
+    def track name, sql
+      return unless sql && accepted_name?(name)
+
+      if name.match(/CACHE/)
+        cache_counts.track name
+      elsif truncate(sql).match(/SELECT/) || name.match(/LOAD/)
+        read_counts.track(sql)
+      else
+        write_counts.track(sql)
+      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
+    end
+
+    private
+
+    def accepted_name?(name)
+      !!(name && !blocked_names.include?(name))
+    end
+
+    def truncate(sql, length=15)
+      sql ||= ''
+      sql.strip[0..length]
+    end
+
+  end
+end

data/lib/canvas_statsd/statsd.rb

@@ -0,0 +1,104 @@
+#
+# Copyright (C) 2012 Instructure, Inc.
+#
+# This file is part of Canvas.
+#
+# Canvas is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, version 3 of the License.
+#
+# Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+# Proxy class to communicate messages to statsd
+# Available statsd messages are described in:
+#   https://github.com/etsy/statsd/blob/master/README.md
+#   https://github.com/reinh/statsd/blob/master/lib/statsd.rb
+#
+# So for instance:
+#   ms = Benchmark.ms { ..code.. }
+#   CanvasStatsd::Statsd.timing("my_stat", ms)
+#
+# Configured in config/statsd.yml, see config/statsd.yml.example
+# At least a host needs to be defined for the environment, all other config is optional
+#
+# If a namespace is defined in statsd.yml, it'll be prepended to the stat name.
+# The hostname of the server will be appended to the stat name, unless `append_hostname: false` is specified in the config.
+# So if the namespace is "canvas" and the hostname is "app01", the final stat name of "my_stat" would be "stats.canvas.my_stat.app01"
+# (assuming the default statsd/graphite configuration)
+#
+# If statsd isn't configured and enabled, then calls to CanvasStatsd::Statsd.* will do nothing and return nil
+
+module CanvasStatsd
+  module Statsd
+    # replace "." in key names with another character to avoid creating spurious sub-folders in graphite
+    def self.escape(str, replacement = '_')
+      str.gsub('.', replacement)
+    end
+
+    def self.hostname
+      @hostname ||= Socket.gethostname.split(".").first
+    end
+
+    %w(increment decrement count gauge timing).each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+      def self.#{method}(stat, *args)
+        if self.instance
+          if Array === stat
+            stat.each do |st|
+              self.#{method}(st, *args)
+            end
+            return
+          end
+
+          if self.append_hostname?
+            stat_name = "\#{stat}.\#{hostname}"
+          else
+            stat_name = stat.to_s
+          end
+          self.instance.#{method}(stat_name, *args)
+        else
+          nil
+        end
+      end
+      RUBY
+    end
+
+    def self.time(stat, sample_rate=1)
+      start = Time.now
+      result = yield
+      self.timing(stat, ((Time.now - start) * 1000).round, sample_rate)
+      result
+    end
+
+    def self.instance
+      if !defined?(@statsd)
+        statsd_settings = CanvasStatsd.settings
+
+        if statsd_settings && statsd_settings[:host]
+          @statsd = ::Statsd.new(statsd_settings[:host])
+          @statsd.port = statsd_settings[:port] if statsd_settings[:port]
+          @statsd.namespace = statsd_settings[:namespace] if statsd_settings[:namespace]
+          @append_hostname = !statsd_settings.key?(:append_hostname) || !!statsd_settings[:append_hostname]
+        else
+          @statsd = nil
+        end
+      end
+      @statsd
+    end
+
+    def self.append_hostname?
+      @append_hostname
+    end
+
+    def self.reset_instance
+      remove_instance_variable(:@statsd) if defined?(@statsd)
+    end
+  end
+end

data/spec/canvas_statsd/canvas_statsd_spec.rb

@@ -0,0 +1,125 @@
+#
+# Copyright (C) 2014 Instructure, Inc.
+#
+# This file is part of Canvas.
+#
+# Canvas is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, version 3 of the License.
+#
+# Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'spec_helper'
+
+describe CanvasStatsd do
+  before(:each) do
+    CanvasStatsd.settings = nil
+  end
+
+  after(:each) do
+    [
+      'CANVAS_STATSD_HOST',
+      'CANVAS_STATSD_NAMESPACE',
+      'CANVAS_STATSD_PORT',
+      'CANVAS_STATSD_APPEND_HOST_NAME',
+    ].each {|k| ENV.delete k}
+  end
+
+  describe ".settings" do
+    it "have default settings" do
+      expect(CanvasStatsd.settings).to eq({})
+    end
+
+    it "can be assigned a new value" do
+      settings = {foo: 'bar', baz: 'apple'}
+      CanvasStatsd.settings = settings
+
+      expect(CanvasStatsd.settings).to eq settings
+    end
+
+    it 'pulls from ENV if not already set' do
+      ENV['CANVAS_STATSD_HOST'] = 'statsd.example.org'
+      ENV['CANVAS_STATSD_NAMESPACE'] = 'canvas'
+
+      expected = {
+        host: 'statsd.example.org',
+        namespace: 'canvas',
+      }
+      expect(CanvasStatsd.settings).to eq(expected)
+
+    end
+
+    it 'configured settings take precedence over ENV settings' do
+      ENV['CANVAS_STATSD_HOST'] = 'statsd.example.org'
+      ENV['CANVAS_STATSD_NAMESPACE'] = 'canvas'
+
+      settings = {foo: 'bar', baz: 'apple'}
+      CanvasStatsd.settings = settings
+      expect(CanvasStatsd.settings).to eq settings
+    end
+  end
+
+  describe ".env_settings" do
+    it 'returns empty hash when no CANVAS_STATSD_HOST found' do
+      env = {
+        'CANVAS_STATSD_NAMESPACE' => 'canvas'
+      }
+      expect(CanvasStatsd.env_settings(env)).to eq({})
+    end
+
+    it 'builds settings hash from environment vars' do
+      env = {
+        'CANVAS_STATSD_HOST' => 'statsd.example.org',
+        'CANVAS_STATSD_NAMESPACE' => 'canvas',
+      }
+      expected = {
+        host: 'statsd.example.org',
+        namespace: 'canvas',
+      }
+      expect(CanvasStatsd.env_settings(env)).to eq(expected)
+    end
+
+    it 'uses ENV if env argument hash not passed' do
+      ENV['CANVAS_STATSD_HOST'] = 'statsd.example.org'
+      ENV['CANVAS_STATSD_NAMESPACE'] = 'canvas'
+
+      expected = {
+        host: 'statsd.example.org',
+        namespace: 'canvas',
+      }
+      expect(CanvasStatsd.env_settings).to eq(expected)
+    end
+
+    it 'converts env append_hostname "false" to boolean' do
+      env = {
+        'CANVAS_STATSD_HOST' => 'statsd.example.org',
+        'CANVAS_STATSD_APPEND_HOSTNAME' => 'false',
+      }
+      expected = {
+        host: 'statsd.example.org',
+        append_hostname: false,
+      }
+      expect(CanvasStatsd.env_settings(env)).to eq(expected)
+    end
+
+    it 'converts env append_hostname "true" to boolean' do
+      env = {
+        'CANVAS_STATSD_HOST' => 'statsd.example.org',
+        'CANVAS_STATSD_APPEND_HOSTNAME' => 'true',
+      }
+      expected = {
+        host: 'statsd.example.org',
+        append_hostname: true,
+      }
+      expect(CanvasStatsd.env_settings(env)).to eq(expected)
+    end
+  end
+
+end

data/spec/canvas_statsd/counter_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe CanvasStatsd::Counter do
+
+  let(:subject) { CanvasStatsd::Counter.new('test', ['foo']) }
+
+  describe "#accepted_name?" do
+    it 'should return true for names not in blocked_names' do
+      expect(subject.accepted_name?('bar')).to eq true
+    end
+
+    it 'should return false for names in blocked_names' do
+      expect(subject.accepted_name?('foo')).to eq false
+    end
+
+    it 'should return true for empty string names' do
+      expect(subject.accepted_name?('')).to eq true
+    end
+
+    it 'should return true for empty nil names' do
+      expect(subject.accepted_name?(nil)).to eq true
+    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
+      subject.track('bar')
+      subject.track('baz')
+      expect(subject.count).to eq 2
+    end
+
+    it 'should not increment when given a blocked name' do
+      subject.start
+      subject.track('foo') #shouldn't count as foo is a blocked name
+      subject.track('name')
+      expect(subject.count).to eq 1
+    end
+  end
+
+  describe "#finalize_count" do
+    it 'should return the current count' do
+      subject.start
+      subject.track('bar')
+      expect(subject.finalize_count).to eq 1
+    end
+
+    it 'should reset the current count to 0' do
+      subject.start
+      subject.track('bar')
+      subject.finalize_count
+      expect(subject.count).to eq 0
+    end
+  end
+
+end

data/spec/canvas_statsd/default_tracking_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+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
+  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
+

data/spec/canvas_statsd/request_stat_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+
+def create_subject(payload={}, statsd=nil)
+  args = ['name', 1000, 1001, 1234, payload]
+  args << statsd if statsd
+  CanvasStatsd::RequestStat.new(*args)
+end
+
+
+describe CanvasStatsd::RequestStat do
+
+  describe '#db_runtime' do
+    it 'should return the payload db_runtime' do
+      rs = create_subject({db_runtime: 11.11})
+      expect(rs.db_runtime).to eq 11.11
+    end
+
+    it 'should return nil when payload db_runtime key doesnt exists' do
+      rs = create_subject
+      expect(rs.db_runtime).to eq nil
+    end
+  end
+
+  describe '#view_runtime' do
+    it 'should return the payload view_runtime' do
+      rs = create_subject(view_runtime: 11.11)
+      expect(rs.view_runtime).to eq 11.11
+    end
+
+    it 'should return nil when payload view_runtime key doesnt exists' do
+      rs = create_subject
+      expect(rs.view_runtime).to eq nil
+    end
+  end
+
+  describe '#controller' do
+    it "should return params['controller']" do
+      rs = create_subject({params: {'controller' => 'foo'}})
+      expect(rs.controller).to eq 'foo'
+    end
+
+    it 'should return nil if no params are available' do
+      rs = create_subject
+      expect(rs.controller).to eq nil
+    end
+
+    it 'should return nil if no controller is available on params' do
+      rs = create_subject({params: {}})
+      expect(rs.controller).to eq nil
+    end
+  end
+
+  describe '#action' do
+    it "should return params['action']" do
+      rs = create_subject({params: {'action' => 'index'}})
+      expect(rs.action).to eq 'index'
+    end
+
+    it 'should return nil if no params are available' do
+      rs = create_subject
+      expect(rs.action).to eq nil
+    end
+
+    it 'should return nil if no action is available on params' do
+      rs = create_subject({params: {}})
+      expect(rs.action).to eq nil
+    end
+  end
+
+  describe '#ms' 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
+    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
+      rs = CanvasStatsd::RequestStat.new('name', 1, nil, 1111, {params: {}})
+      expect(rs.ms).to eq 0
+    end
+  end
+
+  describe '#report' do
+    it 'doesnt send stats when no controller or action' do
+      statsd = double
+      rs = create_subject({params: {}}, statsd)
+      expect(statsd).to_not receive(:timing).with('request.foo.index', 1000)
+      rs.report
+    end
+
+    it 'sends total timing when controller && action are present, doesnt send db, or view if they are not' do
+      statsd = double
+      payload = {
+        params: {
+          'controller' => 'foo',
+          'action'     => 'index'
+        }
+      }
+      rs = create_subject(payload, statsd)
+      expect(statsd).to receive(:timing).with('request.foo.index.total', 1000)
+      rs.report
+    end
+
+    it 'sends view_runtime and db_runtime when present' do
+      statsd = double
+      payload = {
+        view_runtime: 70.1,
+        db_runtime: 100.2,
+        params: {
+          'controller' => 'foo',
+          'action'     => 'index'
+        }
+      }
+      rs = create_subject(payload, statsd)
+      allow(statsd).to receive(:timing).with('request.foo.index.total', 1000)
+      expect(statsd).to receive(:timing).with('request.foo.index.view', 70.1)
+      expect(statsd).to receive(:timing).with('request.foo.index.db', 100.2)
+      rs.report
+    end
+
+    describe 'sql stats' do
+
+      before :each do
+        @statsd = double
+        payload = {
+          params: {
+            'controller' => 'foo',
+            'action'     => 'index'
+          }
+        }
+        @rs = create_subject(payload, @statsd)
+      end
+
+      it 'doesnt send sql stats when they dont exist' do
+        allow(@statsd).to receive(:timing).with('request.foo.index.total', 1000)
+        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.read', kind_of(Numeric))
+        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.write', kind_of(Numeric))
+        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.cache', kind_of(Numeric))
+        @rs.report
+      end
+
+      it 'sends sql_read_count when present' do
+        @rs.sql_read_count = 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
+
+end

data/spec/canvas_statsd/sql_tracker_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module CanvasStatsd
+  describe SqlTracker do
+
+    describe '#start' do
+      it 'resets values to zero' do
+        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)
+      end
+    end
+
+    describe '#track' do
+      before :each do
+        @subject = SqlTracker.new
+        @subject.start
+      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)
+      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)
+      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)
+      end
+
+      it 'doesnt track names set as blocked' do
+        tracker = SqlTracker.new(blocked_names: ['SCHEMA'])
+        tracker.start
+        tracker.track 'SCHEMA', 'SELECT * FROM some_table'
+        expect(tracker.num_reads).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)
+      end
+
+      it 'passes full sql to counter.track calls for reads' do
+        sql = '  SELECT \'context_external_tools\'.* FROM'
+        read_counter = double()
+        allow(read_counter).to receive(:start)
+        expect(read_counter).to receive(:track).with sql
+        tracker = SqlTracker.new(read_counter: read_counter)
+        tracker.start
+        tracker.track 'LOAD', sql
+      end
+
+      it 'passes full sql to counter.track calls for writes' do
+        sql = '  UPDATE \'context_external_tools\'.* FROM'
+        write_counter = double()
+        allow(write_counter).to receive(:start)
+        expect(write_counter).to receive(:track).with sql
+        tracker = SqlTracker.new(write_counter: write_counter)
+        tracker.start
+        tracker.track 'UPDATE', sql
+      end
+    end
+
+  end
+end

data/spec/canvas_statsd/statsd_spec.rb

@@ -0,0 +1,74 @@
+#
+# Copyright (C) 2012 Instructure, Inc.
+#
+# This file is part of Canvas.
+#
+# Canvas is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, version 3 of the License.
+#
+# Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'spec_helper'
+
+describe CanvasStatsd::Statsd do
+  METHODS = %w(increment decrement count gauge timing)
+
+  it "appends the hostname to stat names by default" do
+    CanvasStatsd::Statsd.stub(:hostname).and_return("testhost")
+    statsd = double
+    CanvasStatsd::Statsd.stub(:instance).and_return(statsd)
+    CanvasStatsd::Statsd.stub(:append_hostname?).and_return(true)
+    METHODS.each do |method|
+      expect(statsd).to receive(method).with("test.name.testhost", "test")
+      CanvasStatsd::Statsd.send(method, "test.name", "test")
+    end
+    expect(statsd).to receive("timing").with("test.name.testhost", anything, anything)
+    expect(CanvasStatsd::Statsd.time("test.name") { "test" }).to eq "test"
+  end
+
+  it "omits hostname if specified in config" do
+    expect(CanvasStatsd::Statsd).to receive(:hostname).never
+    statsd = double
+    CanvasStatsd::Statsd.stub(:instance).and_return(statsd)
+    CanvasStatsd::Statsd.stub(:append_hostname?).and_return(false)
+    METHODS.each do |method|
+      expect(statsd).to receive(method).with("test.name", "test")
+      CanvasStatsd::Statsd.send(method, "test.name", "test")
+    end
+    expect(statsd).to receive("timing").with("test.name", anything, anything)
+    expect(CanvasStatsd::Statsd.time("test.name") { "test" }).to eq "test"
+  end
+
+  it "ignores all calls if statsd isn't enabled" do
+    CanvasStatsd::Statsd.stub(:instance).and_return(nil)
+    METHODS.each do |method|
+      expect(CanvasStatsd::Statsd.send(method, "test.name")).to be_nil
+    end
+    expect(CanvasStatsd::Statsd.time("test.name") { "test" }).to eq "test"
+  end
+
+  it "configures a statsd instance" do
+    expect(CanvasStatsd::Statsd.instance).to be_nil
+
+    CanvasStatsd.settings = { :host => "testhost", :namespace => "test", :port => 1234 }
+    CanvasStatsd::Statsd.reset_instance
+
+    instance = CanvasStatsd::Statsd.instance
+    expect(instance).to be_a ::Statsd
+    expect(instance.host).to eq "testhost"
+    expect(instance.port).to eq 1234
+    expect(instance.namespace).to eq "test"
+  end
+
+  after do
+    CanvasStatsd::Statsd.reset_instance
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'canvas_statsd'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end

data/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+result=0
+
+echo "################ canvas_statsd ################"
+echo "################ Running tests against Rails 3 ################"
+bundle check || bundle install
+bundle exec rspec spec
+let result=$result+$?
+
+if [ $result -eq 0 ]; then
+  echo "SUCCESS"
+else
+  echo "FAILURE"
+fi
+
+exit $result

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: canvas_statsd
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Nick Cloward
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: statsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: aroi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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'
+description: 
+email:
+- ncloward@instructure.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/canvas_statsd.rb
+- lib/canvas_statsd/counter.rb
+- lib/canvas_statsd/default_tracking.rb
+- lib/canvas_statsd/request_stat.rb
+- lib/canvas_statsd/sql_tracker.rb
+- lib/canvas_statsd/statsd.rb
+- spec/canvas_statsd/canvas_statsd_spec.rb
+- spec/canvas_statsd/counter_spec.rb
+- spec/canvas_statsd/default_tracking_spec.rb
+- spec/canvas_statsd/request_stat_spec.rb
+- spec/canvas_statsd/sql_tracker_spec.rb
+- spec/canvas_statsd/statsd_spec.rb
+- spec/spec_helper.rb
+- test.sh
+homepage: https://github.com/instructure/canvas_statsd
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Statsd for Canvas
+test_files:
+- spec/canvas_statsd/canvas_statsd_spec.rb
+- spec/canvas_statsd/counter_spec.rb
+- spec/canvas_statsd/default_tracking_spec.rb
+- spec/canvas_statsd/request_stat_spec.rb
+- spec/canvas_statsd/sql_tracker_spec.rb
+- spec/canvas_statsd/statsd_spec.rb
+- spec/spec_helper.rb
+has_rdoc: