collective-metrics 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38cbe392ebdab08135fb07eda42511cb2af92383
-  data.tar.gz: 7c95091a0665ae20eb66df3090402a21b021cd90
+  metadata.gz: 867d160cc98d20a4135bd89a7e20818ca0a59523
+  data.tar.gz: 14a2dee02b5a23b46e485d3734fbdf8f09b5bf9d
 SHA512:
-  metadata.gz: 74345281798d952090dfa93fef3cbe40dd92f9c20390eed768f3b879e555b74e0d0b8bbcaf937833c737845fd5be535244785d8376dccbecad8ad3c2359b3d07
-  data.tar.gz: 9985f3810e6f1c75708c527cee766b1019c52db720deaa89a42a2b9ece81dddffad93d76fdfcd6c826562acc0006fd979e7509172dd810bdb998c01b5428507e
+  metadata.gz: d95c2229f1ee18d673702c209ff9a508e0e4f32f20f0c4060c7f69f7b0625b02650a9f2617aaccce8097bf7bad46cf2d893dafaf74c010592bc9ef39c78c24a1
+  data.tar.gz: 505be1fbd644e0a3580bbec41c9218bb7a53ce8f817d8c3fd2fd837ac5403c2cf96385e23f3ed9147439d39e7260ba3a0124ff7d0ab2b10d4d9e75f43a6f5f54

data/Collectfile

@@ -4,4 +4,6 @@ use Collective::Collectors::Memcached
 unless ENV['NEWRELIC_API_KEY'].nil? || ENV['NEWRELIC_API_KEY'].empty?
   use Collective::Collectors::Newrelic, api_key: ENV['NEWRELIC_API_KEY'], filter: ENV['NEWRELIC_APPLICATION_FILTER']
 end
-
+unless ENV['TRACKJS_API_KEY'].nil? || ENV['TRACKJS_API_KEY'].empty?
+  use Collective::Collectors::TrackJS, api_key: ENV['TRACKJS_API_KEY'], customer_id: ENV['TRACKJS_CUSTOMER_ID']
+end

data/Gemfile

@@ -6,6 +6,17 @@ gemspec
 group :development do
   gem 'dalli'
   gem 'sidekiq'
-  gem 'mongoid', '~> 3.0'
+  gem 'mongoid',       '~> 3.0'
   gem 'pg'
 end
+
+group :development, :test do
+  gem 'rspec',         '~> 3.4.0'
+  gem 'dotenv',        '~> 2.1.1'
+  gem 'faker'
+  gem 'activesupport'
+end
+
+group :test do
+  gem 'webmock'
+end

data/lib/collective/collectors/trackjs.rb

@@ -0,0 +1,112 @@
+module Collective::Collectors
+  class TrackJS < Collective::Collector
+    requires :faraday
+    requires :faraday_middleware
+    requires :json
+    @@frequency = 60 # seconds
+
+    resolution @@frequency.to_s + 's'
+
+    def initialize(options = {})
+      @last_seen_id = options[:last_seen_id] || {}
+      super(options)
+    end
+
+    collect do
+      options[:applications].each do |application|
+        instrument_errors application
+      end
+    end
+
+    private
+
+    def instrument_errors(application)
+      count = 0
+      paged("/#{customer_id}/v1/errors", {application: application}).each do |error|
+        count += 1
+      end
+      instrument 'trackjs.url.errors', count, source: application, type: 'count'
+    end
+
+    # This function goes through a paged list of errors and yields each
+    # individual error.
+    #
+    # The most basic endpoint in the TrackJS API returns all the errors that
+    # have been detected from the beginning of time to the current date. This
+    # endpoint can return the number of errors seen in the last day, but since
+    # we're just trying to determine the number of errors that occurred in the
+    # last 60s, we use the default endpoint options.
+    #
+    # To avoid fetching all the errors, only the ones we haven't seen since
+    # the last time we checked, so we keep track of the id of the last error
+    # we saw and page through the error list until either:
+    #
+    # 1. We see an error we've already returned
+    # 2. We hit an errors that's more than 60s old (to avoid scanning the entire list of
+    #    errors the first time the collector is run)
+    # 3. We hit the very end of the error list
+    #
+    def paged(path, params={})
+      Enumerator.new do |yielder|
+        current_error_time = Time.now.utc
+        oldest_error = current_error_time - @@frequency
+        page = 1
+        page_size = 250
+        current_initial_id = nil
+        get_another_page = true # set to true until an error id that has already been seen is hit
+        application = params[:application]
+
+        resp = get_page(path, params, page, page_size)
+        data = resp.body['data']
+
+        if data.length > 0
+          current_initial_id = data[0]['id']
+
+          while current_error_time > oldest_error do
+            resp.body['data'].each do |error|
+              current_error_time = Time.parse(error['timestamp'])
+              if (error['id'] == @last_seen_id[application]) || (current_error_time <= oldest_error)
+                get_another_page = false
+                break
+              else
+                yielder.yield error
+              end
+            end
+
+            break if !get_another_page or !resp.body['metadata']['hasMore']
+
+            page += 1
+            resp = get_page(path, params, page, page_size)
+          end
+
+          @last_seen_id[application] = current_initial_id
+        end
+      end
+    end
+
+    def get_page(path, params, page, page_size = 500)
+      client.get(path, params.merge(page: page, size: page_size)) do |req|
+        req.headers['Authorization'] = api_key
+      end
+    end
+
+    def client
+      @client ||= Faraday.new(api_url) do |builder|
+        builder.response :json, content_type: /\bjson$/
+        builder.adapter Faraday.default_adapter
+      end
+    end
+
+    def api_url
+      "https://api.trackjs.com"
+    end
+
+    def customer_id
+      options[:customer_id]
+    end
+
+    def api_key
+      options[:api_key]
+    end
+  end
+end

data/lib/collective/version.rb

@@ -1,3 +1,3 @@
 module Collective
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end

data/lib/collective.rb

@@ -17,6 +17,7 @@ module Collective
     autoload :Newrelic,    'collective/collectors/newrelic'
     autoload :PGBouncer,   'collective/collectors/pgbouncer'
     autoload :Postgres,    'collective/collectors/postgres'
+    autoload :TrackJS,     'collective/collectors/trackjs'
   end
 
   class << self

data/spec/lib/collective/collectors/trackjs_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+require 'collective'
+require 'active_support/core_ext/numeric/time'
+
+describe Collective::Collectors::TrackJS do
+  let(:env_api_key) { ENV["TRACKJS_API_KEY"] }
+  let(:env_customer_id) { ENV["TRACKJS_CUSTOMER_ID"] }
+  let(:page_size) { 250 }
+  let(:page) { 1 }
+  let(:no_errors) { 0 }
+  let(:empty_response) { trackjs_response errors: no_errors, total_errors: no_errors, page: page, page_size: page_size }
+
+  before do
+    @collector = Collective::Collectors::TrackJS.new(
+      :api_key => env_api_key,
+      :customer_id => env_customer_id
+    )
+  end
+
+  context 'when no errors are returned' do
+    let(:errors) { 0 }
+    let(:response) { trackjs_response errors: errors, total_errors: errors, page: page, page_size: page_size }
+
+    it 'logs an error count of 0' do
+      stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+        .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+        .to_return(
+          :body => response.to_json,
+          :status => 200,
+          :headers => {'Content-Type' => 'application/json'}
+        )
+      stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+        .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+        .to_return(
+          :body => response.to_json,
+          :status => 200,
+          :headers => {'Content-Type' => 'application/json'}
+        )
+
+      expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-frontend"))
+      expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-marketing"))
+      @collector.collect
+      expect(
+        a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+      ).to have_been_made
+      expect(
+        a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+      ).to have_been_made
+    end
+  end
+
+  context 'when less than a page of errors are returned' do
+    let(:error_count) { 45 }
+    let(:metadata) { trackjs_metadata total_count: error_count, page: page, page_size: page_size, has_more: false }
+    let(:response) { trackjs_response errors: error_count, total_errors: error_count, page: page, page_size: page_size }
+
+    context 'when none of the errors have been logged before' do
+      context 'all the errors are within the last @frequency seconds' do
+        it 'logs all the errors returned' do
+          stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+            .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+            .to_return(
+              :body => response.to_json,
+              :status => 200,
+              :headers => {'Content-Type' => 'application/json'}
+            )
+          stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+            .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+            .to_return(
+              :body => empty_response.to_json,
+              :status => 200,
+              :headers => {'Content-Type' => 'application/json'}
+            )
+
+          expect(Metrics).to receive(:instrument).with('trackjs.url.errors', error_count, hash_including(:source => "r101-frontend"))
+          expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-marketing"))
+          @collector.collect
+          expect(
+            a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+          ).to have_been_made
+          expect(
+            a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+          ).to have_been_made
+        end
+      end
+
+      context 'not all the errors are within the last @frequency seconds' do
+        let(:old_error_count) { 7 }
+        let(:old_timestamps) { old_error_count.times.map { 3.hours.ago.utc.strftime("%FT%T%:z") } }
+        let(:old_errors) { old_error_count.times.map { |i| trackjs_error({timestamp: old_timestamps[i]}) } }
+        let(:errors) { (error_count - old_error_count).times.map { trackjs_error} + old_errors }
+        let(:response) { { "data" => errors, "metadata" => metadata } }
+
+        it 'logs only the errors in the last @frequency s' do
+          stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+            .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+            .to_return(
+              :body => response.to_json,
+              :status => 200,
+              :headers => {'Content-Type' => 'application/json'}
+            )
+          stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+            .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+            .to_return(
+              :body => empty_response.to_json,
+              :status => 200,
+              :headers => {'Content-Type' => 'application/json'}
+            )
+
+          expect(Metrics).to receive(:instrument).with('trackjs.url.errors', error_count - old_error_count, hash_including(:source => "r101-frontend"))
+          expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-marketing"))
+          @collector.collect
+          expect(
+            a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+          ).to have_been_made
+          expect(
+            a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+          ).to have_been_made
+        end
+      end
+
+      context 'none of the errors are within the last @frequency seconds' do
+        let(:old_timestamps) { error_count.times.map { 3.hours.ago.utc.strftime("%FT%T%:z") } }
+        let(:errors) { error_count.times.map { |i| trackjs_error({timestamp: old_timestamps[i]}) } }
+        let(:response) { { "data" => errors, "metadata" => metadata } }
+
+        it 'logs 0 errors' do
+          stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+            .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+            .to_return(
+              :body => response.to_json,
+              :status => 200,
+              :headers => {'Content-Type' => 'application/json'}
+            )
+          stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+            .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+            .to_return(
+              :body => empty_response.to_json,
+              :status => 200,
+              :headers => {'Content-Type' => 'application/json'}
+            )
+
+          expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-frontend"))
+          expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-marketing"))
+          @collector.collect
+          expect(
+            a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+          ).to have_been_made
+          expect(
+            a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+          ).to have_been_made
+        end
+      end
+    end
+
+    context 'some of the errors have been logged before' do
+      let(:old_error_count) { 5 }
+      let(:new_error_count) { 3 }
+      let(:old_errors) { old_error_count.times.map { trackjs_error } }
+      let(:new_errors) { new_error_count.times.map { trackjs_error } }
+      let(:all_errors) { new_errors + old_errors }
+      let(:old_metadata) { trackjs_metadata total_count: old_error_count, page: page, page_size: page_size, has_more: false }
+      let(:new_metadata) { trackjs_metadata total_count: (old_error_count + new_error_count), page: page, page_size: page_size, has_more: false }
+      let(:old_response) { {"data" => old_errors, "metadata" => old_metadata} }
+      let(:new_response) { {"data" => all_errors, "metadata" => new_metadata} }
+
+      before do
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+          .to_return(
+            :body => empty_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+          .to_return(
+            :body => old_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+
+        @collector.collect
+      end
+
+      it 'logs only the errors that have occurred since the last time logging happened' do
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+          .to_return(
+            :body => empty_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+          .to_return(
+            :body => new_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+
+        expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-frontend"))
+        expect(Metrics).to receive(:instrument).with('trackjs.url.errors', new_errors.length, hash_including(:source => "r101-marketing"))
+        @collector.collect
+        expect(
+          a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+        ).to have_been_made.times(2)
+        expect(
+          a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+        ).to have_been_made.times(2)
+      end
+    end
+  end
+
+  context 'when multiple pages of errors are returned' do
+    let(:old_error_count) { 250 }
+    let(:new_error_count) { 50 }
+    let(:total_errors) { 800 }
+    let(:page2) { 2 }
+
+    context 'none of the errors have been logged before' do
+      let(:recent_timestamps) { old_error_count.times.map { Time.now.utc.strftime("%FT%T%:z") } }
+      let(:old_timestamps) { new_error_count.times.map { 3.hours.ago.utc.strftime("%FT%T%:z") } }
+      let(:combined_timestamps) { recent_timestamps.slice(0, old_error_count - new_error_count) + old_timestamps }
+      let(:response) { trackjs_response errors: old_error_count, timestamps: recent_timestamps, total_errors: total_errors, page: page, page_size: page_size }
+      let(:response2) { trackjs_response errors: old_error_count, timestamps: combined_timestamps, total_errors: total_errors, page: page2, page_size: page_size }
+
+      it 'logs only the errors that occurred in the last @frequency seconds' do
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+          .to_return(
+            :body => response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+          .to_return(
+            :body => empty_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page2, "size" => page_size, "application" => "r101-frontend"})
+          .to_return(
+            :body => response2.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page2, "size" => page_size, "application" => "r101-marketing"})
+          .to_return(
+            :body => empty_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+
+        expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 2 * page_size - old_timestamps.length, hash_including(:source => "r101-frontend"))
+        expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-marketing"))
+        @collector.collect
+        expect(
+          a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+        ).to have_been_made.times(1)
+        expect(
+          a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+        ).to have_been_made.times(1)
+      end
+    end
+
+    context 'some of the errors have been logged before' do
+      let(:page1_errors) { old_error_count.times.map { trackjs_error } }
+      let(:old_timestamps) { new_error_count.times.map { 3.hours.ago.utc.strftime("%FT%T%:z") } }
+      let(:out_of_date_errors) { new_error_count.times.map { |i| trackjs_error({timestamp: old_timestamps[i]}) } }
+      let(:page2_errors) { ((old_error_count - new_error_count).times.map { trackjs_error }) + out_of_date_errors }
+      let(:new_errors) { new_error_count.times.map { trackjs_error } }
+      let(:combined_errors) { (new_errors + page1_errors).first page_size }
+      let(:old_metadata) { trackjs_metadata total_count: old_error_count, page: page, page_size: page_size, has_more: true }
+      let(:combined_metadata) { trackjs_metadata total_count: (old_error_count + new_error_count), page: page2, page_size: page_size, has_more: true }
+      let(:old_page1_response) { { "data" => page1_errors, "metadata" => old_metadata } }
+      let(:old_page2_response) { { "data" => page2_errors, "metadata" => old_metadata } }
+      let(:combined_response) { { "data" => combined_errors, "metadata" => combined_metadata } }
+
+      before do
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+          .to_return(
+            :body => old_page1_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+          .to_return(
+            :body => empty_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page2, "size" => page_size, "application" => "r101-frontend"})
+          .to_return(
+            :body => old_page2_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page2, "size" => page_size, "application" => "r101-marketing"})
+          .to_return(
+            :body => empty_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        @collector.collect
+      end
+
+      it 'logs only the errors that have occurred since the last time logging happened' do
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+          .to_return(
+            :body => combined_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        stub_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors")
+          .with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+          .to_return(
+            :body => empty_response.to_json,
+            :status => 200,
+            :headers => {'Content-Type' => 'application/json'}
+          )
+        expect(Metrics).to receive(:instrument).with('trackjs.url.errors', new_errors.length, hash_including(:source => "r101-frontend"))
+        expect(Metrics).to receive(:instrument).with('trackjs.url.errors', 0, hash_including(:source => "r101-marketing"))
+        @collector.collect
+        expect(
+          a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-frontend"})
+        ).to have_been_made.times(2)
+        expect(
+          a_request(:get, "https://api.trackjs.com/#{env_customer_id}/v1/errors").with(:query => {"page" => page, "size" => page_size, "application" => "r101-marketing"})
+        ).to have_been_made.times(2)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'webmock/rspec'
+
+require 'dotenv'
+Dotenv.load('.env.test')
+
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.raise_errors_for_deprecations!
+
+  # Allow RSpec to run focused specs
+  config.filter_run_including focus: true
+  config.filter_run_excluding broken: true
+  config.filter_run_excluding :bollocksed
+  config.run_all_when_everything_filtered = true
+  config.fail_fast = false
+  config.before focus: true do
+    fail "Hey dummy, don't commit focused specs." if ENV['CI']
+  end
+end

data/spec/support/trackjs_helpers.rb

@@ -0,0 +1,65 @@
+require 'securerandom'
+require 'faker'
+
+module TrackJSHelpers
+  def trackjs_error(
+    message: nil,
+    timestamp: Time.now.utc.strftime("%FT%T%:z"),
+    url: "https://www.remind.com",
+    application: "r101-frontend",
+    id: SecureRandom.uuid
+  )
+    trackjs_url = "https://my.trackjs.com/details/#{id}"
+    message = message || Faker::Lorem.sentence
+
+    return {
+      "message" => message,
+      "timestamp" => timestamp,
+      "url" => url,
+      "id" => id,
+      "browserName" => "Chrome",
+      "browserVersion" => "49.0.2623",
+      "entry" => "window",
+      "application" => application,
+      "line" => 11,
+      "column" => 13161,
+      "file" => "https://www.remind.com/classes/sci02",
+      "userId" => "11111111",
+      "sessionId" => "",
+      "trackJsUrl" => trackjs_url,
+      "isStarred" => false
+    }
+  end
+
+  def trackjs_metadata(total_count: 0, page: 1, page_size: 250, has_more: true)
+    return {
+      "totalCount" => total_count,
+      "page" => page,
+      "size" => page_size,
+      "hasMore" => has_more,
+      "trackJsUrl" => "https://my.trackjs.com/recent?"
+    }
+  end
+
+  def trackjs_response(errors: 0, timestamps: nil, total_errors: 0, page: 1, page_size: 250)
+    timestamps = timestamps || errors.times.map { Time.now.utc.strftime("%FT%T%:z") }
+    data = errors.times.map do |i|
+      trackjs_error(timestamp: timestamps[i])
+    end
+    has_more = (page * page_size) < total_errors
+
+    return {
+      "data" => data,
+      "metadata" => trackjs_metadata(
+        total_count: total_errors,
+        page: page,
+        page_size: page_size,
+        has_more: has_more
+      )
+    }
+  end
+end
+
+RSpec.configure do |config|
+  config.include TrackJSHelpers
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: collective-metrics
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Eric J. Holmes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-28 00:00:00.000000000 Z
+date: 2016-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rufus-scheduler
@@ -159,7 +159,11 @@ files:
 - lib/collective/collectors/rabbitmq.rb
 - lib/collective/collectors/redis.rb
 - lib/collective/collectors/sidekiq.rb
+- lib/collective/collectors/trackjs.rb
 - lib/collective/version.rb
+- spec/lib/collective/collectors/trackjs_spec.rb
+- spec/spec_helper.rb
+- spec/support/trackjs_helpers.rb
 homepage: https://github.com/remind101/collective-metrics
 licenses:
 - MIT
@@ -180,8 +184,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Collect and output metrics
-test_files: []
+test_files:
+- spec/lib/collective/collectors/trackjs_spec.rb
+- spec/spec_helper.rb
+- spec/support/trackjs_helpers.rb