appsignal 0.11.18 → 0.12.beta.0

data/lib/appsignal/transmitter.rb

@@ -30,7 +30,7 @@ module Appsignal
     end
 
     def uri
-      @uri ||= URI("#{config[:endpoint]}/#{action}").tap do |uri|
+      @uri ||= URI("#{config[:endpoint]}/1/#{action}").tap do |uri|
         uri.query = ::Rack::Utils.build_query({
           :api_key => config[:push_api_key],
           :name => config[:name],
@@ -41,12 +41,7 @@ module Appsignal
       end
     end
 
-    # Accepts a string or `Appsignal::ZippedPayload`
-    # If no `Appsignal::ZippedPayload` is given, it will convert it to one.
     def transmit(payload)
-      unless payload.is_a?(Appsignal::ZippedPayload)
-        payload = Appsignal::ZippedPayload.new(payload)
-      end
       Appsignal.logger.debug "Transmitting payload to #{uri}"
       http_client.request(http_post(payload)).code
     end
@@ -57,45 +52,21 @@ module Appsignal
       Net::HTTP::Post.new(uri.request_uri).tap do |request|
         request['Content-Type'] = CONTENT_TYPE
         request['Content-Encoding'] = CONTENT_ENCODING
-        request.body = payload.body
+        request.body = Zlib::Deflate.deflate(
+          JSON.generate(payload, :quirks_mode => true),
+          Zlib::BEST_SPEED
+        )
       end
     end
 
     def http_client
-      client = if config[:http_proxy]
-        Net::HTTP.new(uri.host, uri.port, proxy_addr, proxy_port)
-      else
-        Net::HTTP.new(uri.host, uri.port)
-      end
-
-      client.tap do |http|
+      Net::HTTP.new(uri.host, uri.port).tap do |http|
         if uri.scheme == 'https'
-          http.use_ssl     = true
-          http.ssl_version = :TLSv1
+          http.use_ssl = true
           http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-          http.ca_file     = CA_FILE_PATH
+          http.ca_file = CA_FILE_PATH
         end
       end
     end
-
-    def proxy_uri
-      @proxy_uri ||= URI.parse(config[:http_proxy])
-    end
-
-    def proxy_addr
-      if config[:http_proxy]
-        proxy_uri.host
-      else
-        nil
-      end
-    end
-
-    def proxy_port
-      if config[:http_proxy]
-        proxy_uri.port
-      else
-        nil
-      end
-    end
   end
 end

data/lib/appsignal/version.rb

@@ -1,3 +1,4 @@
 module Appsignal
-  VERSION = '0.11.18'
+  VERSION       = '0.12.beta.0'
+  AGENT_VERSION = 'eea0fcb'
 end

data/spec/lib/appsignal/config_spec.rb

@@ -21,7 +21,7 @@ describe Appsignal::Config do
         :instrument_net_http            => true,
         :skip_session_data              => false,
         :send_params                    => true,
-        :endpoint                       => 'https://push.appsignal.com/1',
+        :endpoint                       => 'https://push.appsignal.com',
         :slow_request_threshold         => 200,
         :push_api_key                   => 'abc',
         :name                           => 'TestApp',
@@ -41,6 +41,24 @@ describe Appsignal::Config do
       end
     end
 
+    describe "#write_to_environment" do
+      before do
+        subject.write_to_environment
+      end
+
+      it "should write the current config to env vars" do
+        ENV['APPSIGNAL_ACTIVE'].should            == 'true'
+        ENV['APPSIGNAL_APP_PATH'].should          end_with('spec/support/project_fixture')
+        ENV['APPSIGNAL_AGENT_PATH'].should        end_with('/ext')
+        ENV['APPSIGNAL_LOG_PATH'].should          end_with('/log')
+        ENV['APPSIGNAL_PUSH_API_ENDPOINT'].should == 'https://push.appsignal.com'
+        ENV['APPSIGNAL_PUSH_API_KEY'].should      == 'abc'
+        ENV['APPSIGNAL_APP_NAME'].should          == 'TestApp'
+        ENV['APPSIGNAL_ENVIRONMENT'].should       == 'production'
+        ENV['APPSIGNAL_AGENT_VERSION'].should     == Appsignal::AGENT_VERSION
+      end
+    end
+
     context "if the env is passed as a symbol" do
       let(:config) { project_fixture_config(:production) }
 
@@ -63,7 +81,6 @@ describe Appsignal::Config do
       it "should merge with the config" do
         subject[:name].should == 'TestApp'
         subject[:initial_key].should == 'value'
-        subject[:ignore_exceptions].should == []
       end
     end
 
@@ -91,6 +108,11 @@ describe Appsignal::Config do
   end
 
   context "when there is no config file" do
+    before do
+      ENV.keys.select { |key| key.start_with?('APPSIGNAL_') }.each do |key|
+        ENV[key] = nil
+      end
+    end
     let(:initial_config) { {} }
     let(:config) { Appsignal::Config.new('/nothing', 'production', initial_config) }
 
@@ -136,7 +158,7 @@ describe Appsignal::Config do
           :send_params                    => true,
           :instrument_net_http            => true,
           :skip_session_data              => false,
-          :endpoint                       => 'https://push.appsignal.com/1',
+          :endpoint                       => 'https://push.appsignal.com',
           :slow_request_threshold         => 200,
           :active                         => true,
           :enable_frontend_error_catching => false,
@@ -150,7 +172,6 @@ describe Appsignal::Config do
         it "should merge with the config" do
           Appsignal.logger.should_not_receive(:debug)
           subject[:name].should == 'Initial Name'
-          subject[:ignore_exceptions].should == []
         end
       end
 

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+if rails_present?
+  require 'action_view'
+
+  describe Appsignal::EventFormatter::ActionView::RenderFormatter do
+    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
+    end
+
+    describe "#root_path" do
+      its(:root_path) { should == '/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'} }
+
+        it { should == ['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} }
+
+        it { should == ['app/views/home/index/html.erb', nil] }
+      end
+
+      context "without an identifier" do
+        let(:payload) { {} }
+
+        it { should be_nil }
+      end
+    end
+  end
+end

data/spec/lib/appsignal/{aggregator/middleware/active_record_sanitizer_spec.rb → event_formatter/active_record/sql_formatter_spec.rb}

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
-if active_record_present?
+if rails_present?
   require 'active_record'
-  require 'appsignal/aggregator/middleware/active_record_sanitizer'
 
-  describe Appsignal::Aggregator::Middleware::ActiveRecordSanitizer do
-    let(:klass) { Appsignal::Aggregator::Middleware::ActiveRecordSanitizer }
-    let(:sql_event_sanitizer) { klass.new }
+  describe Appsignal::EventFormatter::ActiveRecord::SqlFormatter do
+    let(:klass) { Appsignal::EventFormatter::ActiveRecord::SqlFormatter }
+    let(:formatter) { klass.new }
     let(:connection_config) { {} }
     before do
       if ActiveRecord::Base.respond_to?(:connection_config)
@@ -23,80 +22,82 @@ if active_record_present?
       end
     end
 
-    describe "#call" do
-      let(:name) { 'Model load' }
-      let(:binds) { [] }
-      let(:event) do
-        notification_event(
-          :name => 'sql.active_record',
-          :payload => create_payload(
-            :name => name,
-            :sql => sql,
-            :binds => binds,
-            :connection_id => 1111
-          )
-        )
+    pending "should register sql.activerecord" do
+      Appsignal::EventFormatter.registered?('sql.active_record', klass).should be_true
+    end
+
+    context "if a connection cannot be established" do
+      before do
+        ActiveRecord::Base.stub(:connection_config).and_raise(ActiveRecord::ConnectionNotEstablished)
       end
-      subject { event.payload[:sql] }
-      before { sql_event_sanitizer.call(event) { } }
 
-      context "connection id and bindings" do
-        let(:sql) { '' }
-        subject { event.payload }
+      it "should log the error and unregister the formatter" do
+        Appsignal.logger.should_receive(:error).with(
+          'Error while getting ActiveRecord connection info, unregistering sql.active_record event formatter'
+        )
+
+        lambda {
+          formatter
+        }.should_not raise_error
 
-        it { should_not have_key(:connection_id) }
-        it { should_not have_key(:binds) }
+        Appsignal::EventFormatter.registered?('sql.active_record').should be_false
       end
+    end
+
+    describe "#format" do
+      let(:name) { 'Model load' }
+      let(:payload) { {:sql => sql, :name => name} }
+      subject { formatter.format(payload) }
 
       context "with backtick table names" do
-        before { sql_event_sanitizer.stub(:adapter_uses_double_quoted_table_names? => false) }
+        before { formatter.stub(:adapter_uses_double_quoted_table_names => false) }
 
         context "single quoted data value" do
           let(:sql) { "SELECT `table`.* FROM `table` WHERE `id` = 'secret'" }
 
-          it { should == "SELECT `table`.* FROM `table` WHERE `id` = ?" }
+          it { should == ['Model load', "SELECT `table`.* FROM `table` WHERE `id` = ?"] }
 
           context "with an escaped single quote" do
             let(:sql) { "`id` = '\\'big\\' secret'" }
 
-            it { should == "`id` = ?" }
+            it { should == ['Model load', "`id` = ?"] }
           end
 
           context "with an escaped double quote" do
             let(:sql) { "`id` = '\\\"big\\\" secret'" }
 
-            it { should == "`id` = ?" }
+            it { should == ['Model load', "`id` = ?"] }
           end
         end
 
         context "double quoted data value" do
           let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` = "secret"' }
 
-          it { should == 'SELECT `table`.* FROM `table` WHERE `id` = ?' }
+          it { should == ['Model load', 'SELECT `table`.* FROM `table` WHERE `id` = ?'] }
 
           context "with an escaped single quote" do
             let(:sql) { '`id` = "\\\'big\\\' secret"' }
 
-            it { should == "`id` = ?" }
+            it { should == ['Model load', "`id` = ?"] }
           end
 
           context "with an escaped double quote" do
             let(:sql) { '`id` = "\\"big\\" secret"' }
 
-            it { should == "`id` = ?" }
+            it { should == ['Model load', "`id` = ?"] }
           end
         end
 
         context "numeric parameter" do
           let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` = 1' }
 
-          it { should == 'SELECT `table`.* FROM `table` WHERE `id` = ?' }
+          it { should == ['Model load', 'SELECT `table`.* FROM `table` WHERE `id` = ?'] }
         end
 
         context "parameter array" do
           let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` IN (1, 2)' }
 
-          it { should == 'SELECT `table`.* FROM `table` WHERE `id` IN (?)' }
+          it { should == ['Model load', 'SELECT `table`.* FROM `table` WHERE `id` IN (?)'] }
         end
       end
 
@@ -106,25 +107,25 @@ if active_record_present?
         context "single quoted data value" do
           let(:sql) { "SELECT \"table\".* FROM \"table\" WHERE \"id\" = 'secret'" }
 
-          it { should == "SELECT \"table\".* FROM \"table\" WHERE \"id\" = ?" }
+          it { should == ['Model load', "SELECT \"table\".* FROM \"table\" WHERE \"id\" = ?"] }
 
           context "with an escaped single quote" do
             let(:sql) { "\"id\" = '\\'big\\' secret'" }
 
-            it { should == "\"id\" = ?" }
+            it { should == ['Model load', "\"id\" = ?"] }
           end
 
           context "with an escaped double quote" do
             let(:sql) { "\"id\" = '\\\"big\\\" secret'" }
 
-            it { should == "\"id\" = ?" }
+            it { should == ['Model load', "\"id\" = ?"] }
           end
         end
 
         context "numeric parameter" do
           let(:sql) { 'SELECT "table".* FROM "table" WHERE "id"=1' }
 
-          it { should == 'SELECT "table".* FROM "table" WHERE "id"=?' }
+          it { should == ['Model load', 'SELECT "table".* FROM "table" WHERE "id"=?'] }
         end
       end
 
@@ -133,27 +134,26 @@ if active_record_present?
 
         let(:sql) { 'SELECT "table".* FROM "table" WHERE "id"=$1' }
 
-        it { should == 'SELECT "table".* FROM "table" WHERE "id"=$1' }
+        it { should == ['Model load', 'SELECT "table".* FROM "table" WHERE "id"=$1'] }
       end
 
-      context "skip sanitization for schema queries" do
+      context "return nil for schema queries" do
         let(:name) { 'SCHEMA' }
         let(:sql) { 'SET client_min_messages TO 22' }
 
-        it { should == 'SET client_min_messages TO 22' }
+        it { should be_nil }
       end
 
       context "with a a frozen sql string" do
         let(:sql) { "SELECT `table`.* FROM `table` WHERE `id` = 'secret'".freeze }
 
-        it { should == "SELECT `table`.* FROM `table` WHERE `id` = ?" }
+        it { should == ['Model load', "SELECT `table`.* FROM `table` WHERE `id` = ?"] }
       end
     end
 
     describe "#schema_query?" do
       let(:payload) { {} }
-      let(:event) { notification_event(:payload => payload) }
-      subject { sql_event_sanitizer.schema_query?(event) }
+      subject { formatter.send(:schema_query?, payload) }
 
       it { should be_false }
 
@@ -168,13 +168,13 @@ if active_record_present?
       describe "#connection_config" do
         let(:connection_config) { {:adapter => 'adapter'} }
 
-        subject { sql_event_sanitizer.connection_config }
+        subject { formatter.send(:connection_config) }
 
         it { should == {:adapter => 'adapter'} }
       end
 
-      describe "#adapter_uses_double_quoted_table_names?" do
-        subject { sql_event_sanitizer.adapter_uses_double_quoted_table_names? }
+      describe "#adapter_uses_double_quoted_table_names" do
+        subject { formatter.adapter_uses_double_quoted_table_names }
 
         context "when using mysql" do
           let(:connection_config) { {:adapter => 'mysql'} }
@@ -193,27 +193,27 @@ if active_record_present?
 
           it { should be_true }
         end
-      end
 
-      describe "adapter_uses_prepared_statements?" do
-        subject { sql_event_sanitizer.adapter_uses_prepared_statements? }
+        describe "adapter_uses_prepared_statements" do
+          subject { formatter.adapter_uses_prepared_statements }
 
-        context "when using mysql" do
-          let(:connection_config) { {:adapter => 'mysql'} }
+          context "when using mysql" do
+            let(:connection_config) { {:adapter => 'mysql'} }
 
-          it { should be_false }
-        end
+            it { should be_false }
+          end
 
-        context "when using postgresql" do
-          let(:connection_config) { {:adapter => 'postgresql'} }
+          context "when using postgresql" do
+            let(:connection_config) { {:adapter => 'postgresql'} }
 
-          it { should be_true }
-        end
+            it { should be_true }
+          end
 
-        context "when using postgresql and prepared statements is disabled" do
-          let(:connection_config) { {:adapter => 'postgresql', :prepared_statements => false} }
+          context "when using postgresql and prepared statements is disabled" do
+            let(:connection_config) { {:adapter => 'postgresql', :prepared_statements => false} }
 
-          it { should be_false }
+            it { should be_false }
+          end
         end
       end
     end

data/spec/lib/appsignal/{event/moped_event_spec.rb → event_formatter/moped/query_formatter_spec.rb}

@@ -1,23 +1,25 @@
 require 'spec_helper'
 
-describe Appsignal::Event::MopedEvent do
-  let(:event) do
-    Appsignal::Event::MopedEvent.new('query.moped', 1, 2, 123, {})
+describe Appsignal::EventFormatter::Moped::QueryFormatter do
+  let(:klass) { Appsignal::EventFormatter::Moped::QueryFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register query.moped" do
+    Appsignal::EventFormatter.registered?('query.moped', klass).should be_true
   end
 
-  describe "#transform_payload" do
-    before { event.stub(:payload_from_op => {'foo' => 'bar'}) }
+  describe "#format" do
+    let(:payload) { {:ops => [op]} }
+    subject { formatter.format(payload) }
+
+    context "without ops in the payload" do
+      let(:payload) { {} }
 
-    it "should map the operations to a normalized payload" do
-      expect( event.transform_payload(:ops => [{}]) ).to eq(
-        :ops => [{'foo' => 'bar'}]
-      )
+      it { should be_nil }
     end
-  end
 
-  describe "#payload_from_op" do
-    context "Moped::Protocol::Query" do
-      let(:payload) do
+    context "Moped::Protocol::Command" do
+      let(:op) do
         double(
           :full_collection_name => 'database.collection',
           :selector             => {'_id' => 'abc'},
@@ -25,17 +27,11 @@ describe Appsignal::Event::MopedEvent do
         )
       end
 
-      it "should transform the payload" do
-        expect( event.payload_from_op(payload) ).to eq(
-          :type     => "Command",
-          :database => "database.collection",
-          :selector => {"_id" => "?"}
-        )
-      end
+      it { should == ['Command', '{:database=>"database.collection", :selector=>{"_id"=>"?"}}'] }
     end
 
     context "Moped::Protocol::Query" do
-      let(:payload) do
+      let(:op) do
         double(
           :full_collection_name => 'database.collection',
           :selector             => {'_id' => 'abc'},
@@ -47,21 +43,11 @@ describe Appsignal::Event::MopedEvent do
         )
       end
 
-      it "should transform the payload" do
-        expect( event.payload_from_op(payload) ).to eq(
-          :type     => "Query",
-          :database => "database.collection",
-          :selector => {"_id" => "?"},
-          :flags    => [],
-          :limit    => 0,
-          :skip     => 0,
-          :fields   => nil,
-        )
-      end
+      it { should == ['Query', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :flags=>[], :limit=>0, :skip=>0, :fields=>nil}'] }
     end
 
     context "Moped::Protocol::Delete" do
-      let(:payload) do
+      let(:op) do
         double(
           :full_collection_name => 'database.collection',
           :selector             => {'_id' => 'abc'},
@@ -70,18 +56,11 @@ describe Appsignal::Event::MopedEvent do
         )
       end
 
-      it "should transform the payload" do
-        expect( event.payload_from_op(payload) ).to eq(
-          :type     => "Delete",
-          :database => "database.collection",
-          :selector => {"_id" => "?"},
-          :flags    => []
-        )
-      end
+      it { should == ['Delete', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :flags=>[]}'] }
     end
 
     context "Moped::Protocol::Insert" do
-      let(:payload) do
+      let(:op) do
         double(
           :full_collection_name => 'database.collection',
           :flags                => [],
@@ -90,18 +69,11 @@ describe Appsignal::Event::MopedEvent do
         )
       end
 
-      it "should transform the payload" do
-        expect( event.payload_from_op(payload) ).to eq(
-          :type      => "Insert",
-          :database  => "database.collection",
-          :flags     => [],
-          :documents => [{"_id" => "?"}, {"_id" => "?"}]
-        )
-      end
+      it { should == ['Insert', '{:database=>"database.collection", :documents=>[{"_id"=>"?"}, {"_id"=>"?"}], :flags=>[]}'] }
     end
 
     context "Moped::Protocol::Update" do
-      let(:payload) do
+      let(:op) do
         double(
           :full_collection_name => 'database.collection',
           :selector             => {'_id' => 'abc'},
@@ -111,47 +83,29 @@ describe Appsignal::Event::MopedEvent do
         )
       end
 
-      it "should transform the payload" do
-        expect( event.payload_from_op(payload) ).to eq(
-          :type     => "Update",
-          :database => "database.collection",
-          :selector => {"_id" => "?"},
-          :update   => {"name" => "?"},
-          :flags    => []
-        )
-      end
+      it { should == ['Update', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :update=>{"name"=>"?"}, :flags=>[]}'] }
     end
 
     context "Moped::Protocol::KillCursors" do
-      let(:payload) do
+      let(:op) do
         double(
           :number_of_cursor_ids => 2,
           :class                => double(:to_s => 'Moped::Protocol::KillCursors')
         )
       end
 
-      it "should transform the payload" do
-        expect( event.payload_from_op(payload) ).to eq(
-          :type                 => "KillCursors",
-          :number_of_cursor_ids => 2
-        )
-      end
+      it { should == ['KillCursors', '{:number_of_cursor_ids=>2}'] }
     end
 
     context "Moped::Protocol::Other" do
-      let(:payload) do
+      let(:op) do
         double(
           :full_collection_name => 'database.collection',
           :class                => double(:to_s => 'Moped::Protocol::Other')
         )
       end
 
-      it "should transform the payload" do
-        expect( event.payload_from_op(payload) ).to eq(
-          :type     => "Other",
-          :database => "database.collection"
-        )
-      end
+      it { should == ['Other', '{:database=>"database.collection"}'] }
     end
   end
 
@@ -160,7 +114,7 @@ describe Appsignal::Event::MopedEvent do
       let(:params) { {'foo' => 'bar'} }
 
       it "should sanitize all hash values with a questionmark" do
-        expect( event.sanitize(params) ).to eq('foo' => '?')
+        expect( formatter.send(:sanitize, params) ).to eq('foo' => '?')
       end
     end
 
@@ -168,7 +122,7 @@ describe Appsignal::Event::MopedEvent do
       let(:params) { [{'foo' => 'bar'}] }
 
       it "should sanitize all hash values with a questionmark" do
-        expect( event.sanitize(params) ).to eq([{'foo' => '?'}])
+        expect( formatter.send(:sanitize, params) ).to eq([{'foo' => '?'}])
       end
     end
 
@@ -176,14 +130,14 @@ describe Appsignal::Event::MopedEvent do
       let(:params) { ['foo', 'bar'] }
 
       it "should sanitize all hash values with a single questionmark" do
-        expect( event.sanitize(params) ).to eq(['?'])
+        expect( formatter.send(:sanitize, params) ).to eq(['?'])
       end
     end
     context "when params is a string" do
       let(:params) { 'bar'}
 
       it "should sanitize all hash values with a questionmark" do
-        expect( event.sanitize(params) ).to eq('?')
+        expect( formatter.send(:sanitize, params) ).to eq('?')
       end
     end
   end