appsignal 2.1.0.alpha.3 → 2.1.0.beta.1

data/spec/lib/appsignal/event_formatter/action_view/render_formatter_spec.rb

@@ -1,33 +1,33 @@
 if DependencyHelper.rails_present?
-  require 'action_view'
+  require "action_view"
 
   describe Appsignal::EventFormatter::ActionView::RenderFormatter do
-    before { Rails.root.stub(:to_s => '/var/www/app/20130101') }
+    before { Rails.root.stub(:to_s => "/var/www/app/20130101") }
     let(:klass) { Appsignal::EventFormatter::ActionView::RenderFormatter }
     let(:formatter) { klass.new }
 
     it "should register render_partial.action_view and render_template.action_view" do
-      Appsignal::EventFormatter.registered?('render_partial.action_view', klass).should be_true
-      Appsignal::EventFormatter.registered?('render_template.action_view', klass).should be_true
+      Appsignal::EventFormatter.registered?("render_partial.action_view", klass).should be_true
+      Appsignal::EventFormatter.registered?("render_template.action_view", klass).should be_true
     end
 
     describe "#root_path" do
-      its(:root_path) { should eq '/var/www/app/20130101/' }
+      its(:root_path) { should eq "/var/www/app/20130101/" }
     end
 
     describe "#format" do
       subject { formatter.format(payload) }
 
       context "with an identifier" do
-        let(:payload) { {:identifier => '/var/www/app/20130101/app/views/home/index/html.erb'} }
+        let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb" } }
 
-        it { should eq ['app/views/home/index/html.erb', nil] }
+        it { should eq ["app/views/home/index/html.erb", nil] }
       end
 
       context "with a frozen identifier" do
-        let(:payload) { {:identifier => '/var/www/app/20130101/app/views/home/index/html.erb'.freeze} }
+        let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb".freeze } }
 
-        it { should eq ['app/views/home/index/html.erb', nil] }
+        it { should eq ["app/views/home/index/html.erb", nil] }
       end
 
       context "without an identifier" do

data/spec/lib/appsignal/event_formatter/active_record/instantiation_formatter_spec.rb

@@ -3,19 +3,19 @@ describe Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter do
   let(:formatter) { klass.new }
 
   it "should register instantiation.active_record" do
-    Appsignal::EventFormatter.registered?('instantiation.active_record', klass).should be_true
+    Appsignal::EventFormatter.registered?("instantiation.active_record", klass).should be_true
   end
 
   describe "#format" do
     let(:payload) do
       {
-        record_count: 1,
-        class_name: 'User'
+        :record_count => 1,
+        :class_name => "User"
       }
     end
 
     subject { formatter.format(payload) }
 
-    it { should eq ['User', nil] }
+    it { should eq ["User", nil] }
   end
 end

data/spec/lib/appsignal/event_formatter/active_record/sql_formatter_spec.rb

@@ -3,19 +3,19 @@ describe Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter do
   let(:formatter) { klass.new }
 
   it "should register sql.active_record" do
-    Appsignal::EventFormatter.registered?('sql.active_record', klass).should be_true
+    Appsignal::EventFormatter.registered?("sql.active_record", klass).should be_true
   end
 
   describe "#format" do
     let(:payload) do
       {
-        name: 'User load',
-        sql: 'SELECT * FROM users'
+        :name => "User load",
+        :sql => "SELECT * FROM users"
       }
     end
 
     subject { formatter.format(payload) }
 
-    it { should eq ['User load', 'SELECT * FROM users', 1] }
+    it { should eq ["User load", "SELECT * FROM users", 1] }
   end
 end

data/spec/lib/appsignal/event_formatter/elastic_search/search_formatter_spec.rb

@@ -4,21 +4,21 @@ describe Appsignal::EventFormatter::ElasticSearch::SearchFormatter do
 
   it "should register query.moped" do
     expect(
-      Appsignal::EventFormatter.registered?('search.elasticsearch', klass)
+      Appsignal::EventFormatter.registered?("search.elasticsearch", klass)
     ).to be_true
   end
 
   describe "#format" do
     let(:payload) do
       {
-        :name   => 'Search',
-        :klass  => 'User',
-        :search => {:index => 'users', :type => 'user', :q => 'John Doe'}
+        :name   => "Search",
+        :klass  => "User",
+        :search => { :index => "users", :type => "user", :q => "John Doe" }
       }
     end
 
     it "should return a payload with name and sanitized body" do
-      expect( formatter.format(payload) ).to eql([
+      expect(formatter.format(payload)).to eql([
         "Search: User",
         "{:index=>\"users\", :type=>\"user\", :q=>\"?\"}"
       ])
@@ -28,25 +28,25 @@ describe Appsignal::EventFormatter::ElasticSearch::SearchFormatter do
   describe "#sanitized_search" do
     let(:search) do
       {
-        :index => 'users',
-        :type  => 'user',
-        :q     => 'John Doe',
-        :other => 'Other'
+        :index => "users",
+        :type  => "user",
+        :q     => "John Doe",
+        :other => "Other"
       }
     end
 
     it "should sanitize non-whitelisted params" do
       expect(
         formatter.sanitized_search(search)
-      ).to eql({:index => 'users', :type => 'user', :q => '?', :other => '?'})
+      ).to eql(:index => "users", :type => "user", :q => "?", :other => "?")
     end
 
     it "should return nil string when search is nil" do
-      expect( formatter.sanitized_search(nil) ).to be_nil
+      expect(formatter.sanitized_search(nil)).to be_nil
     end
 
     it "should return nil string when search is not a hash" do
-      expect( formatter.sanitized_search([]) ).to be_nil
+      expect(formatter.sanitized_search([])).to be_nil
     end
   end
 end

data/spec/lib/appsignal/event_formatter/faraday/request_formatter_spec.rb

@@ -3,19 +3,19 @@ describe Appsignal::EventFormatter::Faraday::RequestFormatter do
   let(:formatter) { klass.new }
 
   it "should register request.faraday" do
-    Appsignal::EventFormatter.registered?('request.faraday', klass).should be_true
+    Appsignal::EventFormatter.registered?("request.faraday", klass).should be_true
   end
 
   describe "#format" do
     let(:payload) do
       {
-        method: :get,
-        url: URI.parse("http://example.org/hello/world?some=param")
+        :method => :get,
+        :url => URI.parse("http://example.org/hello/world?some=param")
       }
     end
 
     subject { formatter.format(payload) }
 
-    it { should eq ['GET http://example.org', 'GET http://example.org/hello/world'] }
+    it { should eq ["GET http://example.org", "GET http://example.org/hello/world"] }
   end
 end

data/spec/lib/appsignal/event_formatter/mongo_ruby_driver/query_formatter_spec.rb

@@ -6,15 +6,15 @@ describe Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter do
     let(:command) do
       {
         "find"   => "users",
-        "filter" => {"_id" => 1}
+        "filter" => { "_id" => 1 }
       }
     end
 
     it "should apply a strategy for each key" do
-      expect( formatter ).to receive(:apply_strategy)
-        .with(:sanitize_document, {"_id" => 1})
+      expect(formatter).to receive(:apply_strategy)
+        .with(:sanitize_document, "_id" => 1)
 
-      expect( formatter ).to receive(:apply_strategy)
+      expect(formatter).to receive(:apply_strategy)
         .with(:allow, "users")
 
       formatter.format(strategy, command)
@@ -24,7 +24,7 @@ describe Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter do
       let(:strategy) { :bananas }
 
       it "should return an empty hash" do
-        expect( formatter.format(strategy, command) ).to eql({})
+        expect(formatter.format(strategy, command)).to eql({})
       end
     end
 
@@ -32,7 +32,7 @@ describe Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter do
       let(:command) { :bananas }
 
       it "should return an empty hash" do
-        expect( formatter.format(strategy, command) ).to eql({})
+        expect(formatter.format(strategy, command)).to eql({})
       end
     end
   end
@@ -40,61 +40,61 @@ describe Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter do
   describe ".apply_strategy" do
     context "when strategy is allow" do
       let(:strategy) { :allow }
-      let(:value)    { {"_id" => 1} }
+      let(:value)    { { "_id" => 1 } }
 
       it "should return the given value" do
-        expect( formatter.apply_strategy(strategy, value) ).to eql(value)
+        expect(formatter.apply_strategy(strategy, value)).to eql(value)
       end
     end
 
     context "when strategy is deny" do
       let(:strategy) { :deny }
-      let(:value)    { {"_id" => 1} }
+      let(:value)    { { "_id" => 1 } }
 
       it "should return a '?'" do
-        expect( formatter.apply_strategy(strategy, value) ).to eql('?')
+        expect(formatter.apply_strategy(strategy, value)).to eql("?")
       end
     end
 
     context "when strategy is deny_array" do
       let(:strategy) { :deny_array }
-      let(:value)    { {"_id" => 1} }
+      let(:value)    { { "_id" => 1 } }
 
       it "should return a sanitized array string" do
-        expect( formatter.apply_strategy(strategy, value) ).to eql("[?]")
+        expect(formatter.apply_strategy(strategy, value)).to eql("[?]")
       end
     end
 
     context "when strategy is sanitize_document" do
       let(:strategy) { :sanitize_document }
-      let(:value)    { {"_id" => 1} }
+      let(:value)    { { "_id" => 1 } }
 
       it "should return a sanitized document" do
-        expect( formatter.apply_strategy(strategy, value) ).to eql({"_id" => '?'})
+        expect(formatter.apply_strategy(strategy, value)).to eql("_id" => "?")
       end
     end
 
     context "when strategy is sanitize_bulk" do
       let(:strategy) { :sanitize_bulk }
-      let(:value)    { [{"q" => {"_id" => 1}, "u" => [{"foo" => "bar"}]}] }
+      let(:value)    { [{ "q" => { "_id" => 1 }, "u" => [{ "foo" => "bar" }] }] }
 
       it "should return an array of sanitized bulk documents" do
-        expect( formatter.apply_strategy(strategy, value) ).to eql([
-          {"q" => {"_id" => '?'}, "u" => '[?]'}
+        expect(formatter.apply_strategy(strategy, value)).to eql([
+          { "q" => { "_id" => "?" }, "u" => "[?]" }
         ])
       end
 
       context "when bulk has more than one update" do
         let(:value) do
           [
-            {"q" => {"_id" => 1}, "u" => [{"foo" => "bar"}]},
-            {"q" => {"_id" => 2}, "u" => [{"foo" => "baz"}]},
+            { "q" => { "_id" => 1 }, "u" => [{ "foo" => "bar" }] },
+            { "q" => { "_id" => 2 }, "u" => [{ "foo" => "baz" }] }
           ]
         end
 
         it "should return only the first value of sanitized bulk documents" do
-          expect( formatter.apply_strategy(strategy, value) ).to eql([
-            {"q" => {"_id" => '?'}, "u" => '[?]'},
+          expect(formatter.apply_strategy(strategy, value)).to eql([
+            { "q" => { "_id" => "?" }, "u" => "[?]" },
             "[...]"
           ])
         end
@@ -103,10 +103,10 @@ describe Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter do
 
     context "when strategy is missing" do
       let(:strategy) { nil }
-      let(:value)    { {"_id" => 1} }
+      let(:value)    { { "_id" => 1 } }
 
       it "should return a '?'" do
-        expect( formatter.apply_strategy(strategy, value) ).to eql('?')
+        expect(formatter.apply_strategy(strategy, value)).to eql("?")
       end
     end
   end

data/spec/lib/appsignal/event_formatter/moped/query_formatter_spec.rb

@@ -3,11 +3,11 @@ describe Appsignal::EventFormatter::Moped::QueryFormatter do
   let(:formatter) { klass.new }
 
   it "should register query.moped" do
-    Appsignal::EventFormatter.registered?('query.moped', klass).should be_true
+    Appsignal::EventFormatter.registered?("query.moped", klass).should be_true
   end
 
   describe "#format" do
-    let(:payload) { {:ops => [op]} }
+    let(:payload) { { :ops => [op] } }
     subject { formatter.format(payload) }
 
     context "without ops in the payload" do
@@ -19,95 +19,94 @@ describe Appsignal::EventFormatter::Moped::QueryFormatter do
     context "Moped::Protocol::Command" do
       let(:op) do
         double(
-          :full_collection_name => 'database.collection',
-          :selector             => {'query' => {'_id' => 'abc'}},
-          :class                => double(:to_s => 'Moped::Protocol::Command')
+          :full_collection_name => "database.collection",
+          :selector             => { "query" => { "_id" => "abc" } },
+          :class                => double(:to_s => "Moped::Protocol::Command")
         )
       end
 
-      it { should eq ['Command', '{:database=>"database.collection", :selector=>{"query"=>"?"}}'] }
+      it { should eq ["Command", '{:database=>"database.collection", :selector=>{"query"=>"?"}}'] }
     end
 
     context "Moped::Protocol::Query" do
       let(:op) do
         double(
-          :full_collection_name => 'database.collection',
-          :selector             => {'_id' => 'abc'},
+          :full_collection_name => "database.collection",
+          :selector             => { "_id" => "abc" },
           :flags                => [],
           :limit                => 0,
           :skip                 => 0,
           :fields               => nil,
-          :class                => double(:to_s => 'Moped::Protocol::Query')
+          :class                => double(:to_s => "Moped::Protocol::Query")
         )
       end
 
-      it { should eq ['Query', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :flags=>[], :limit=>0, :skip=>0, :fields=>nil}'] }
+      it { should eq ["Query", '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :flags=>[], :limit=>0, :skip=>0, :fields=>nil}'] }
     end
 
     context "Moped::Protocol::Delete" do
       let(:op) do
         double(
-          :full_collection_name => 'database.collection',
-          :selector             => {'_id' => 'abc'},
+          :full_collection_name => "database.collection",
+          :selector             => { "_id" => "abc" },
           :flags                => [],
-          :class                => double(:to_s => 'Moped::Protocol::Delete')
+          :class                => double(:to_s => "Moped::Protocol::Delete")
         )
       end
 
-      it { should eq ['Delete', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :flags=>[]}'] }
+      it { should eq ["Delete", '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :flags=>[]}'] }
     end
 
     context "Moped::Protocol::Insert" do
       let(:op) do
         double(
-          :full_collection_name => 'database.collection',
+          :full_collection_name => "database.collection",
           :flags                => [],
           :documents            => [
-            {'_id' => 'abc', 'events' => {'foo' => [{'bar' => 'baz'}]}},
-            {'_id' => 'def', 'events' => {'foo' => [{'baz' => 'bar'}]}}
+            { "_id" => "abc", "events" => { "foo" => [{ "bar" => "baz" }] } },
+            { "_id" => "def", "events" => { "foo" => [{ "baz" => "bar" }] } }
           ],
-          :class                => double(:to_s => 'Moped::Protocol::Insert')
+          :class                => double(:to_s => "Moped::Protocol::Insert")
         )
       end
 
-      it { should eq ['Insert', '{:database=>"database.collection", :documents=>{"_id"=>"?", "events"=>"?"}, :count=>2, :flags=>[]}'] }
+      it { should eq ["Insert", '{:database=>"database.collection", :documents=>{"_id"=>"?", "events"=>"?"}, :count=>2, :flags=>[]}'] }
     end
 
     context "Moped::Protocol::Update" do
       let(:op) do
         double(
-          :full_collection_name => 'database.collection',
-          :selector             => {'_id' => 'abc'},
-          :update               => {'user.name' => 'James Bond'},
+          :full_collection_name => "database.collection",
+          :selector             => { "_id" => "abc" },
+          :update               => { "user.name" => "James Bond" },
           :flags                => [],
-          :class                => double(:to_s => 'Moped::Protocol::Update')
+          :class                => double(:to_s => "Moped::Protocol::Update")
         )
       end
 
-      it { should eq ['Update', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :update=>{"user.?"=>"?"}, :flags=>[]}'] }
+      it { should eq ["Update", '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :update=>{"user.?"=>"?"}, :flags=>[]}'] }
     end
 
     context "Moped::Protocol::KillCursors" do
       let(:op) do
         double(
           :number_of_cursor_ids => 2,
-          :class                => double(:to_s => 'Moped::Protocol::KillCursors')
+          :class                => double(:to_s => "Moped::Protocol::KillCursors")
         )
       end
 
-      it { should eq ['KillCursors', '{:number_of_cursor_ids=>2}'] }
+      it { should eq ["KillCursors", "{:number_of_cursor_ids=>2}"] }
     end
 
     context "Moped::Protocol::Other" do
       let(:op) do
         double(
-          :full_collection_name => 'database.collection',
-          :class                => double(:to_s => 'Moped::Protocol::Other')
+          :full_collection_name => "database.collection",
+          :class                => double(:to_s => "Moped::Protocol::Other")
         )
       end
 
-      it { should eq ['Other', '{:database=>"database.collection"}'] }
+      it { should eq ["Other", '{:database=>"database.collection"}'] }
     end
   end
-
 end

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -1,14 +1,14 @@
 class MockFormatter < Appsignal::EventFormatter
-  register 'mock'
+  register "mock"
 
   attr_reader :body
 
   def initialize
-    @body = 'some value'
+    @body = "some value"
   end
 
-  def format(payload)
-    ['title', @body]
+  def format(_payload)
+    ["title", @body]
   end
 end
 
@@ -23,7 +23,7 @@ class IncorrectFormatMockFormatter < Appsignal::EventFormatter
 end
 
 class MockDependentFormatter < Appsignal::EventFormatter
-  register 'mock.dependent'
+  register "mock.dependent"
 
   def initialize
     NonsenseDependency.something
@@ -39,62 +39,62 @@ describe Appsignal::EventFormatter do
 
   context "registering and unregistering formatters" do
     it "should register a formatter" do
-      klass.formatters['mock'].should be_instance_of(MockFormatter)
+      klass.formatters["mock"].should be_instance_of(MockFormatter)
     end
 
     it "should know wether a formatter is registered" do
-      klass.registered?('mock').should be_true
-      klass.registered?('mock', MockFormatter).should be_true
-      klass.registered?('mock', Hash).should be_false
-      klass.registered?('nonsense').should be_false
+      klass.registered?("mock").should be_true
+      klass.registered?("mock", MockFormatter).should be_true
+      klass.registered?("mock", Hash).should be_false
+      klass.registered?("nonsense").should be_false
     end
 
     it "doesn't register formatters that raise a name error in the initializer" do
-      klass.registered?('mock.dependent').should be_false
+      klass.registered?("mock.dependent").should be_false
     end
 
     it "doesn't register formatters that don't have a format(payload) method" do
-      klass.register('mock.missing_format', MissingFormatMockFormatter)
-      klass.register('mock.incorrect_format', IncorrectFormatMockFormatter)
+      klass.register("mock.missing_format", MissingFormatMockFormatter)
+      klass.register("mock.incorrect_format", IncorrectFormatMockFormatter)
 
       Appsignal::EventFormatter.initialize_formatters
 
-      klass.registered?('mock.missing_format').should be_false
-      klass.registered?('mock.incorrect_format').should be_false
+      klass.registered?("mock.missing_format").should be_false
+      klass.registered?("mock.incorrect_format").should be_false
     end
 
     it "should register a custom formatter" do
-      klass.register('mock.specific', MockFormatter)
+      klass.register("mock.specific", MockFormatter)
       Appsignal::EventFormatter.initialize_formatters
 
-      klass.formatter_classes['mock.specific'].should eq MockFormatter
-      klass.registered?('mock.specific').should be_true
-      klass.formatters['mock.specific'].should be_instance_of(MockFormatter)
-      klass.formatters['mock.specific'].body.should eq 'some value'
+      klass.formatter_classes["mock.specific"].should eq MockFormatter
+      klass.registered?("mock.specific").should be_true
+      klass.formatters["mock.specific"].should be_instance_of(MockFormatter)
+      klass.formatters["mock.specific"].body.should eq "some value"
     end
 
     it "should not have a formatter that's not registered" do
-      klass.formatters['nonsense'].should be_nil
+      klass.formatters["nonsense"].should be_nil
     end
 
     it "should unregister a formatter if the registered one has the same class" do
-      klass.register('mock.unregister', MockFormatter)
+      klass.register("mock.unregister", MockFormatter)
 
-      klass.unregister('mock.unregister', Hash)
-      klass.registered?('mock.unregister').should be_true
+      klass.unregister("mock.unregister", Hash)
+      klass.registered?("mock.unregister").should be_true
 
-      klass.unregister('mock.unregister', MockFormatter)
-      klass.registered?('mock.unregister').should be_false
+      klass.unregister("mock.unregister", MockFormatter)
+      klass.registered?("mock.unregister").should be_false
     end
   end
 
   context "calling formatters" do
     it "should return nil if there is no formatter registered" do
-      klass.format('nonsense', {}).should be_nil
+      klass.format("nonsense", {}).should be_nil
     end
 
     it "should call the formatter if it is registered and use a value set in the initializer" do
-      klass.format('mock', {}).should eq ['title', 'some value']
+      klass.format("mock", {}).should eq ["title", "some value"]
     end
   end
 end