appsignal 2.5.3 → 2.6.0.beta.1

data/spec/lib/appsignal/config_spec.rb

@@ -30,7 +30,7 @@ describe Appsignal::Config do
   end
 
   describe "config based on the system" do
-    let(:config) { project_fixture_config(:none) }
+    let(:config) { silence { project_fixture_config(:none) } }
 
     describe ":active" do
       subject { config[:active] }
@@ -76,7 +76,9 @@ describe Appsignal::Config do
         "production",
         :push_api_key => "abc",
         :name => "TestApp",
-        :active => true
+        :active => true,
+        :revision => "v2.5.1",
+        :request_headers => []
       )
     end
 
@@ -88,6 +90,7 @@ describe Appsignal::Config do
         :ignore_errors                  => [],
         :ignore_namespaces              => [],
         :filter_parameters              => [],
+        :filter_session_data            => [],
         :instrument_net_http            => true,
         :instrument_redis               => true,
         :instrument_sequel              => true,
@@ -103,10 +106,11 @@ describe Appsignal::Config do
         :enable_gc_instrumentation      => false,
         :enable_host_metrics            => true,
         :enable_minutely_probes         => false,
-        :hostname                       => Socket.gethostname,
         :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
         :dns_servers                    => [],
-        :files_world_accessible         => true
+        :files_world_accessible         => true,
+        :revision                       => "v2.5.1",
+        :request_headers                => []
       )
     end
 
@@ -134,7 +138,8 @@ describe Appsignal::Config do
             described_class.new(
               "non-existing-path",
               "production",
-              :active => false
+              :active => false,
+              :request_headers => []
             )
           end
           before { ENV["APPSIGNAL_PUSH_API_KEY"] = "abc" }
@@ -298,6 +303,8 @@ describe Appsignal::Config do
       ENV["APPSIGNAL_INSTRUMENT_REDIS"]        = "false"
       ENV["APPSIGNAL_INSTRUMENT_SEQUEL"]       = "false"
       ENV["APPSIGNAL_FILES_WORLD_ACCESSIBLE"]  = "false"
+      ENV["APPSIGNAL_REQUEST_HEADERS"]         = "accept,accept-charset"
+      ENV["APP_REVISION"] = "v2.5.1"
     end
 
     it "overrides config with environment values" do
@@ -316,6 +323,8 @@ describe Appsignal::Config do
       expect(config[:instrument_redis]).to eq(false)
       expect(config[:instrument_sequel]).to eq(false)
       expect(config[:files_world_accessible]).to eq(false)
+      expect(config[:request_headers]).to eq(%w[accept accept-charset])
+      expect(config[:revision]).to eq("v2.5.1")
     end
 
     context "with mixed case `true` env variables values" do
@@ -356,7 +365,7 @@ describe Appsignal::Config do
   end
 
   describe "#[]" do
-    let(:config) { project_fixture_config(:none, :push_api_key => "foo") }
+    let(:config) { project_fixture_config(:none, :push_api_key => "foo", :request_headers => []) }
 
     context "with existing key" do
       it "gets the value" do
@@ -400,10 +409,10 @@ describe Appsignal::Config do
       config[:ignore_namespaces] = %w[admin private_namespace]
       config[:log] = "stdout"
       config[:log_path] = "/tmp"
-      config[:hostname] = "app1.local"
       config[:filter_parameters] = %w[password confirm_password]
       config[:running_in_container] = false
       config[:dns_servers] = ["8.8.8.8", "8.8.4.4"]
+      config[:revision] = "v2.5.1"
       config.write_to_environment
     end
 
@@ -423,19 +432,30 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_IGNORE_ACTIONS"]).to               eq "action1,action2"
       expect(ENV["_APPSIGNAL_IGNORE_ERRORS"]).to                eq "ExampleStandardError,AnotherError"
       expect(ENV["_APPSIGNAL_IGNORE_NAMESPACES"]).to            eq "admin,private_namespace"
-      expect(ENV["_APPSIGNAL_FILTER_PARAMETERS"]).to            eq "password,confirm_password"
       expect(ENV["_APPSIGNAL_SEND_PARAMS"]).to                  eq "true"
       expect(ENV["_APPSIGNAL_RUNNING_IN_CONTAINER"]).to         eq "false"
       expect(ENV["_APPSIGNAL_ENABLE_HOST_METRICS"]).to          eq "true"
       expect(ENV["_APPSIGNAL_ENABLE_MINUTELY_PROBES"]).to       eq "false"
-      expect(ENV["_APPSIGNAL_HOSTNAME"]).to                     eq "app1.local"
+      expect(ENV["_APPSIGNAL_HOSTNAME"]).to                     eq ""
       expect(ENV["_APPSIGNAL_PROCESS_NAME"]).to                 include "rspec"
       expect(ENV["_APPSIGNAL_CA_FILE_PATH"]).to                 eq File.join(resources_dir, "cacert.pem")
       expect(ENV["_APPSIGNAL_DNS_SERVERS"]).to                  eq "8.8.8.8,8.8.4.4"
       expect(ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]).to       eq "true"
+      expect(ENV["_APP_REVISION"]).to                           eq "v2.5.1"
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIR_PATH")
     end
 
+    context "with :hostname" do
+      before do
+        config[:hostname] = "Alices-MBP.example.com"
+        config.write_to_environment
+      end
+
+      it "sets the modified :hostname" do
+        expect(ENV["_APPSIGNAL_HOSTNAME"]).to eq "Alices-MBP.example.com"
+      end
+    end
+
     context "with :working_dir_path" do
       before do
         config[:working_dir_path] = "/tmp/appsignal2"
@@ -613,23 +633,61 @@ describe Appsignal::Config do
   end
 
   describe "#validate" do
-    before { config.validate }
     subject { config.valid? }
-    let(:config) { described_class.new(Dir.pwd, "production", :push_api_key => push_api_key) }
+    let(:config) do
+      described_class.new(Dir.pwd, "production", config_options)
+    end
 
-    context "with missing push_api_key" do
-      let(:push_api_key) { nil }
+    describe "push_api_key" do
+      let(:config_options) { { :push_api_key => push_api_key, :request_headers => [] } }
+      before { config.validate }
 
-      it "sets valid to false" do
-        is_expected.to eq(false)
+      context "with missing push_api_key" do
+        let(:push_api_key) { nil }
+
+        it "sets valid to false" do
+          is_expected.to eq(false)
+        end
+      end
+
+      context "with push_api_key present" do
+        let(:push_api_key) { "abc" }
+
+        it "sets valid to true" do
+          is_expected.to eq(true)
+        end
       end
     end
 
-    context "with push_api_key present" do
+    describe "request_headers option validation" do
+      let(:out_stream) { std_stream }
+      let(:output) { out_stream.read }
       let(:push_api_key) { "abc" }
+      let(:config_options) { { :push_api_key => push_api_key } }
+      before do
+        capture_stdout(out_stream) do
+          config.validate
+        end
+      end
 
-      it "sets valid to true" do
-        is_expected.to eq(true)
+      context "with missing request_headers config option" do
+        let(:config_options) { { :push_api_key => "abc" } }
+
+        it "logs a warning" do
+          is_expected.to eq(true)
+          expect(output).to include "Warning: The `request_headers` config " \
+            "option was not set  in the AppSignal configuration"
+        end
+      end
+
+      context "with request_headers config option present" do
+        let(:config_options) { { :push_api_key => "abc", :request_headers => [] } }
+
+        it "logs no warning" do
+          is_expected.to eq(true)
+          expect(output).to_not include "Warning: The `request_headers` config " \
+            "option was not set  in the AppSignal configuration"
+        end
       end
     end
   end

data/spec/lib/appsignal/extension_spec.rb

@@ -103,15 +103,15 @@ describe Appsignal::Extension do
       end
 
       it "should have a set_gauge method" do
-        subject.set_gauge("key", 1.0)
+        subject.set_gauge("key", 1.0, Appsignal::Extension.data_map_new)
       end
 
       it "should have a increment_counter method" do
-        subject.increment_counter("key", 1)
+        subject.increment_counter("key", 1, Appsignal::Extension.data_map_new)
       end
 
       it "should have a add_distribution_value method" do
-        subject.add_distribution_value("key", 1.0)
+        subject.add_distribution_value("key", 1.0, Appsignal::Extension.data_map_new)
       end
     end
   end

data/spec/lib/appsignal/integrations/padrino_spec.rb

@@ -141,7 +141,7 @@ if DependencyHelper.padrino_present?
             it "instruments the request" do
               expect_a_transaction_to_be_created
               # Uses path for action name
-              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:#/404")
+              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp#unknown")
               expect(response).to match_response(404, "<h1>Not Found</h1>")
             end
           end
@@ -162,52 +162,32 @@ if DependencyHelper.padrino_present?
 
           # Older Padrino versions don't support `action` (v11.0+)
           context "without #action on Sinatra::Request" do
-            let(:path) { "/my_original_path" }
-            let(:request_kind) do
-              double(
-                :params => {},
-                :path => path,
-                :path_info => path,
-                :request_method => "GET",
-                :head? => false,
-                :route_obj => double(:original_path => "original_path method"),
-                :route_obj= => nil # Make sure route_obj doesn't get overwritten
-              )
-            end
+            let(:path) { "/my_original_path/10" }
             before do
-              expect(Sinatra::Request).to receive(:new).and_return(request_kind)
-              app.controllers { get(:my_original_path) { "content" } }
+              allow_any_instance_of(Sinatra::Request).to receive(:action).and_return(nil)
+              app.controllers { get(:my_original_path, :with => :id) { "content" } }
             end
             after { expect(response).to match_response(200, "content") }
 
             it "falls back on Sinatra::Request#route_obj.original_path" do
               expect_a_transaction_to_be_created
               expect(transaction)
-                .to receive(:set_action_if_nil).with("PadrinoTestApp:original_path method")
+                .to receive(:set_action_if_nil).with("PadrinoTestApp:/my_original_path/:id")
             end
           end
 
           context "without Sinatra::Request#route_obj.original_path" do
             let(:path) { "/my_original_path" }
-            let(:request_kind) do
-              double(
-                :params => {},
-                :path => path,
-                :path_info => path,
-                :request_method => "GET",
-                :head? => false,
-                :route_obj= => nil # Make sure route_obj doesn't get overwritten
-              )
-            end
             before do
-              expect(Sinatra::Request).to receive(:new).and_return(request_kind)
+              allow_any_instance_of(Sinatra::Request).to receive(:action).and_return(nil)
+              allow_any_instance_of(Sinatra::Request).to receive(:route_obj).and_return(nil)
               app.controllers { get(:my_original_path) { "content" } }
             end
             after { expect(response).to match_response(200, "content") }
 
             it "falls back on app name" do
               expect_a_transaction_to_be_created
-              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp")
+              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp#unknown")
             end
           end
 

data/spec/lib/appsignal/transaction_spec.rb

@@ -912,8 +912,7 @@ describe Appsignal::Transaction do
     end
 
     describe "#sanitized_environment" do
-      let(:whitelisted_keys) { Appsignal::Transaction::ENV_METHODS }
-
+      let(:whitelisted_keys) { Appsignal.config[:request_headers] }
       subject { transaction.send(:sanitized_environment) }
 
       context "when request is nil" do
@@ -940,6 +939,16 @@ describe Appsignal::Transaction do
         it "only sets whitelisted keys" do
           expect(subject.keys).to match_array(whitelisted_keys)
         end
+
+        context "with configured request_headers" do
+          before do
+            Appsignal.config.config_hash[:request_headers] = %w[CONTENT_LENGTH]
+          end
+
+          it "only sets whitelisted keys" do
+            expect(subject.keys).to match_array(%w[CONTENT_LENGTH])
+          end
+        end
       end
     end
 
@@ -970,37 +979,42 @@ describe Appsignal::Transaction do
         it { is_expected.to be_nil }
       end
 
-      context "when there is a session" do
-        before do
-          expect(transaction).to respond_to(:request)
-          allow(transaction).to receive_message_chain(:request, :session => { :foo => :bar })
-          allow(transaction).to receive_message_chain(:request, :fullpath => :bar)
-        end
+      context "with a session" do
+        let(:session_data_filter) { [] }
+        before { Appsignal.config[:filter_session_data] = session_data_filter }
+        after { Appsignal.config[:filter_session_data] = [] }
 
-        it "passes the session data into the params sanitizer" do
-          expect(Appsignal::Utils::ParamsSanitizer).to receive(:sanitize).with(:foo => :bar)
-            .and_return(:sanitized_foo)
-          expect(subject).to eq :sanitized_foo
-        end
+        context "with generic session object" do
+          before do
+            expect(transaction).to respond_to(:request)
+            allow(transaction).to receive_message_chain(
+              :request,
+              :session => { :foo => :bar, :abc => :def }
+            )
+            allow(transaction).to receive_message_chain(:request, :fullpath => :bar)
+          end
 
-        if defined? ActionDispatch::Request::Session
-          context "with ActionDispatch::Request::Session" do
-            before do
-              expect(transaction).to respond_to(:request)
-              allow(transaction).to receive_message_chain(:request, :session => action_dispatch_session)
-              allow(transaction).to receive_message_chain(:request, :fullpath => :bar)
+          context "without session filtering" do
+            it "keeps the session data intact" do
+              expect(subject).to eq(:foo => :bar, :abc => :def)
             end
+          end
+
+          context "with session filtering" do
+            let(:session_data_filter) { %w[foo] }
 
-            it "should return an session hash" do
-              expect(Appsignal::Utils::ParamsSanitizer).to receive(:sanitize).with("foo" => :bar)
-                .and_return(:sanitized_foo)
-              subject
+            it "filters the session data" do
+              expect(subject).to eq(:foo => "[FILTERED]", :abc => :def)
             end
+          end
+        end
 
-            def action_dispatch_session
+        if defined? ActionDispatch::Request::Session
+          context "with ActionDispatch::Request::Session" do
+            let(:action_dispatch_session) do
               store = Class.new do
                 def load_session(_env)
-                  [1, { :foo => :bar }]
+                  [1, { :foo => :bar, :abc => :def }]
                 end
 
                 def session_exists?(_env)
@@ -1009,16 +1023,35 @@ describe Appsignal::Transaction do
               end.new
               ActionDispatch::Request::Session.create(store, ActionDispatch::Request.new("rack.input" => StringIO.new), {})
             end
+            before do
+              expect(transaction).to respond_to(:request)
+              allow(transaction).to receive_message_chain(
+                :request,
+                :session => action_dispatch_session
+              )
+              allow(transaction).to receive_message_chain(:request, :fullpath => :bar)
+            end
+
+            context "without session filtering" do
+              it "keeps the session data intact" do
+                expect(subject).to eq("foo" => :bar, "abc" => :def)
+              end
+            end
+
+            context "with session filtering" do
+              let(:session_data_filter) { %w[foo] }
+
+              it "filters the session data" do
+                expect(subject).to eq("foo" => "[FILTERED]", "abc" => :def)
+              end
+            end
           end
         end
 
         context "when skipping session data" do
-          before do
-            Appsignal.config = { :skip_session_data => true }
-          end
+          before { Appsignal.config[:skip_session_data] = true }
 
-          it "does not pass the session data into the params sanitizer" do
-            expect(Appsignal::Utils::ParamsSanitizer).to_not receive(:sanitize)
+          it "does not set any session data on the transaction" do
             expect(subject).to be_nil
           end
         end

data/spec/lib/appsignal/utils/{params_sanitizer_spec.rb → hash_sanitizer_spec.rb}

@@ -1,4 +1,4 @@
-describe Appsignal::Utils::ParamsSanitizer do
+describe Appsignal::Utils::HashSanitizer do
   let(:file) { uploaded_file }
   let(:params) do
     {
@@ -80,9 +80,9 @@ describe Appsignal::Utils::ParamsSanitizer do
       end
     end
 
-    context "with :filter_parameters option" do
+    context "with filter_keys" do
       let(:sanitized_params) do
-        described_class.sanitize(params, :filter_parameters => %w[text hash])
+        described_class.sanitize(params, %w[text hash])
       end
       subject { sanitized_params }
 
@@ -100,7 +100,7 @@ describe Appsignal::Utils::ParamsSanitizer do
 
       context "with strings as key filter values" do
         let(:sanitized_params) do
-          described_class.sanitize(params, :filter_parameters => %w[string])
+          described_class.sanitize(params, %w[string])
         end
 
         it "sanitizes values" do
@@ -110,7 +110,7 @@ describe Appsignal::Utils::ParamsSanitizer do
 
       describe ":hash" do
         let(:sanitized_params) do
-          described_class.sanitize(params, :filter_parameters => %w[nested_text])
+          described_class.sanitize(params, %w[nested_text])
         end
         subject { sanitized_params[:hash] }
 
@@ -121,7 +121,7 @@ describe Appsignal::Utils::ParamsSanitizer do
         describe ":nested_array" do
           describe ":nested_hash" do
             let(:sanitized_params) do
-              described_class.sanitize(params, :filter_parameters => %w[key])
+              described_class.sanitize(params, %w[key])
             end
             subject { sanitized_params[:hash][:nested_array][3] }