appsignal 2.5.3 → 2.6.0.beta.1

data/spec/lib/appsignal_spec.rb

@@ -425,19 +425,26 @@ describe Appsignal do
     end
 
     describe "custom stats" do
+      let(:tags) { { :foo => "bar" } }
+
       describe ".set_gauge" do
         it "should call set_gauge on the extension with a string key and float" do
-          expect(Appsignal::Extension).to receive(:set_gauge).with("key", 0.1)
+          expect(Appsignal::Extension).to receive(:set_gauge).with("key", 0.1, Appsignal::Extension.data_map_new)
           Appsignal.set_gauge("key", 0.1)
         end
 
+        it "should call set_gauge with tags" do
+          expect(Appsignal::Extension).to receive(:set_gauge).with("key", 0.1, Appsignal::Utils.data_generate(tags))
+          Appsignal.set_gauge("key", 0.1, tags)
+        end
+
         it "should call set_gauge on the extension with a symbol key and int" do
-          expect(Appsignal::Extension).to receive(:set_gauge).with("key", 1.0)
+          expect(Appsignal::Extension).to receive(:set_gauge).with("key", 1.0, Appsignal::Extension.data_map_new)
           Appsignal.set_gauge(:key, 1)
         end
 
         it "should not raise an exception when out of range" do
-          expect(Appsignal::Extension).to receive(:set_gauge).with("key", 10).and_raise(RangeError)
+          expect(Appsignal::Extension).to receive(:set_gauge).with("key", 10, Appsignal::Extension.data_map_new).and_raise(RangeError)
           expect(Appsignal.logger).to receive(:warn).with("Gauge value 10 for key 'key' is too big")
           expect do
             Appsignal.set_gauge("key", 10)
@@ -487,22 +494,27 @@ describe Appsignal do
 
       describe ".increment_counter" do
         it "should call increment_counter on the extension with a string key" do
-          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 1)
+          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 1, Appsignal::Extension.data_map_new)
           Appsignal.increment_counter("key")
         end
 
+        it "should call increment_counter with tags" do
+          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 1, Appsignal::Utils.data_generate(tags))
+          Appsignal.increment_counter("key", 1, tags)
+        end
+
         it "should call increment_counter on the extension with a symbol key" do
-          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 1)
+          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 1, Appsignal::Extension.data_map_new)
           Appsignal.increment_counter(:key)
         end
 
         it "should call increment_counter on the extension with a count" do
-          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 5)
+          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 5, Appsignal::Extension.data_map_new)
           Appsignal.increment_counter("key", 5)
         end
 
         it "should not raise an exception when out of range" do
-          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 10).and_raise(RangeError)
+          expect(Appsignal::Extension).to receive(:increment_counter).with("key", 10, Appsignal::Extension.data_map_new).and_raise(RangeError)
           expect(Appsignal.logger).to receive(:warn).with("Counter value 10 for key 'key' is too big")
           expect do
             Appsignal.increment_counter("key", 10)
@@ -512,17 +524,22 @@ describe Appsignal do
 
       describe ".add_distribution_value" do
         it "should call add_distribution_value on the extension with a string key and float" do
-          expect(Appsignal::Extension).to receive(:add_distribution_value).with("key", 0.1)
+          expect(Appsignal::Extension).to receive(:add_distribution_value).with("key", 0.1, Appsignal::Extension.data_map_new)
           Appsignal.add_distribution_value("key", 0.1)
         end
 
+        it "should call add_distribution_value with tags" do
+          expect(Appsignal::Extension).to receive(:add_distribution_value).with("key", 0.1, Appsignal::Utils.data_generate(tags))
+          Appsignal.add_distribution_value("key", 0.1, tags)
+        end
+
         it "should call add_distribution_value on the extension with a symbol key and int" do
-          expect(Appsignal::Extension).to receive(:add_distribution_value).with("key", 1.0)
+          expect(Appsignal::Extension).to receive(:add_distribution_value).with("key", 1.0, Appsignal::Extension.data_map_new)
           Appsignal.add_distribution_value(:key, 1)
         end
 
         it "should not raise an exception when out of range" do
-          expect(Appsignal::Extension).to receive(:add_distribution_value).with("key", 10).and_raise(RangeError)
+          expect(Appsignal::Extension).to receive(:add_distribution_value).with("key", 10, Appsignal::Extension.data_map_new).and_raise(RangeError)
           expect(Appsignal.logger).to receive(:warn).with("Distribution value 10 for key 'key' is too big")
           expect do
             Appsignal.add_distribution_value("key", 10)
@@ -537,154 +554,6 @@ describe Appsignal do
       it { is_expected.to be_a Logger }
     end
 
-    describe ".start_logger" do
-      let(:out_stream) { std_stream }
-      let(:output) { out_stream.read }
-      let(:log_path) { File.join(tmp_dir, "log") }
-      let(:log_file) { File.join(log_path, "appsignal.log") }
-
-      before do
-        FileUtils.mkdir_p(log_path)
-
-        Appsignal.logger.error("Log in memory")
-        Appsignal.config = project_fixture_config(
-          "production",
-          :log_path => log_path
-        )
-      end
-      after { FileUtils.rm_rf(log_path) }
-
-      context "when the log path is writable" do
-        context "when the log file is writable" do
-          let(:log_file_contents) { File.open(log_file).read }
-
-          before do
-            capture_stdout(out_stream) do
-              Appsignal.start_logger
-              Appsignal.logger.error("Log to file")
-            end
-          end
-
-          it "logs to file" do
-            expect(File.exist?(log_file)).to be_truthy
-            expect(log_file_contents).to include "[ERROR] Log to file"
-            expect(output).to be_empty
-          end
-
-          it "amends in memory log to log file" do
-            expect(log_file_contents).to include "[ERROR] appsignal: Log in memory"
-          end
-        end
-
-        context "when the log file is not writable" do
-          before do
-            FileUtils.touch log_file
-            FileUtils.chmod 0o444, log_file
-
-            capture_stdout(out_stream) do
-              Appsignal.start_logger
-              Appsignal.logger.error("Log to not writable log file")
-            end
-          end
-
-          it "logs to stdout" do
-            expect(File.writable?(log_file)).to be_falsy
-            expect(output).to include "[ERROR] appsignal: Log to not writable log file"
-          end
-
-          it "amends in memory log to stdout" do
-            expect(output).to include "[ERROR] appsignal: Log in memory"
-          end
-
-          it "outputs a warning" do
-            expect(output).to include \
-              "[WARN] appsignal: Unable to start logger with log path '#{log_file}'.",
-              "[WARN] appsignal: Permission denied"
-          end
-        end
-      end
-
-      context "when the log path and fallback path are not writable" do
-        before do
-          FileUtils.chmod 0o444, log_path
-          FileUtils.chmod 0o444, Appsignal::Config.system_tmp_dir
-
-          capture_stdout(out_stream) do
-            Appsignal.start_logger
-            Appsignal.logger.error("Log to not writable log path")
-          end
-        end
-        after do
-          FileUtils.chmod 0o755, Appsignal::Config.system_tmp_dir
-        end
-
-        it "logs to stdout" do
-          expect(File.writable?(log_path)).to be_falsy
-          expect(output).to include "[ERROR] appsignal: Log to not writable log path"
-        end
-
-        it "amends in memory log to stdout" do
-          expect(output).to include "[ERROR] appsignal: Log in memory"
-        end
-
-        it "outputs a warning" do
-          expect(output).to include \
-            "appsignal: Unable to log to '#{log_path}' "\
-            "or the '#{Appsignal::Config.system_tmp_dir}' fallback."
-        end
-      end
-
-      context "when on Heroku" do
-        before do
-          capture_stdout(out_stream) do
-            Appsignal.start_logger
-            Appsignal.logger.error("Log to stdout")
-          end
-        end
-        around { |example| recognize_as_heroku { example.run } }
-
-        it "logs to stdout" do
-          expect(output).to include "[ERROR] appsignal: Log to stdout"
-        end
-
-        it "amends in memory log to stdout" do
-          expect(output).to include "[ERROR] appsignal: Log in memory"
-        end
-      end
-
-      describe "#logger#level" do
-        subject { Appsignal.logger.level }
-
-        context "when there is no config" do
-          before do
-            Appsignal.config = nil
-            capture_stdout(out_stream) do
-              Appsignal.start_logger
-            end
-          end
-
-          it "sets the log level to info" do
-            expect(subject).to eq Logger::INFO
-          end
-        end
-
-        context "when there is a config" do
-          context "when log level is configured to debug" do
-            before do
-              Appsignal.config.config_hash[:debug] = true
-              capture_stdout(out_stream) do
-                Appsignal.start_logger
-              end
-            end
-
-            it "sets the log level to debug" do
-              expect(subject).to eq Logger::DEBUG
-            end
-          end
-        end
-      end
-    end
-
     describe ".log_formatter" do
       subject { Appsignal.log_formatter.call("Debug", Time.parse("2015-07-08"), nil, "log line") }
 
@@ -1046,4 +915,157 @@ describe Appsignal do
       end
     end
   end
+
+  describe ".start_logger" do
+    let(:out_stream) { std_stream }
+    let(:output) { out_stream.read }
+    let(:log_path) { File.join(tmp_dir, "log") }
+    let(:log_file) { File.join(log_path, "appsignal.log") }
+
+    before { FileUtils.mkdir_p(log_path) }
+    after { FileUtils.rm_rf(log_path) }
+
+    def initialize_config
+      Appsignal.config = project_fixture_config(
+        "production",
+        :log_path => log_path
+      )
+      Appsignal.logger.error("Log in memory")
+    end
+
+    context "when the log path is writable" do
+      context "when the log file is writable" do
+        let(:log_file_contents) { File.open(log_file).read }
+
+        before do
+          capture_stdout(out_stream) do
+            initialize_config
+            Appsignal.start_logger
+            Appsignal.logger.error("Log to file")
+          end
+        end
+
+        it "logs to file" do
+          expect(File.exist?(log_file)).to be_truthy
+          expect(log_file_contents).to include "[ERROR] Log to file"
+          expect(output).to be_empty
+        end
+
+        it "amends in memory log to log file" do
+          expect(log_file_contents).to include "[ERROR] appsignal: Log in memory"
+        end
+      end
+
+      context "when the log file is not writable" do
+        before do
+          FileUtils.touch log_file
+          FileUtils.chmod 0o444, log_file
+
+          capture_stdout(out_stream) do
+            initialize_config
+            Appsignal.start_logger
+            Appsignal.logger.error("Log to not writable log file")
+          end
+        end
+
+        it "logs to stdout" do
+          expect(File.writable?(log_file)).to be_falsy
+          expect(output).to include "[ERROR] appsignal: Log to not writable log file"
+        end
+
+        it "amends in memory log to stdout" do
+          expect(output).to include "[ERROR] appsignal: Log in memory"
+        end
+
+        it "outputs a warning" do
+          expect(output).to include \
+            "[WARN] appsignal: Unable to start logger with log path '#{log_file}'.",
+            "[WARN] appsignal: Permission denied"
+        end
+      end
+    end
+
+    context "when the log path and fallback path are not writable" do
+      before do
+        FileUtils.chmod 0o444, log_path
+        FileUtils.chmod 0o444, Appsignal::Config.system_tmp_dir
+
+        capture_stdout(out_stream) do
+          initialize_config
+          Appsignal.start_logger
+          Appsignal.logger.error("Log to not writable log path")
+        end
+      end
+      after do
+        FileUtils.chmod 0o755, Appsignal::Config.system_tmp_dir
+      end
+
+      it "logs to stdout" do
+        expect(File.writable?(log_path)).to be_falsy
+        expect(output).to include "[ERROR] appsignal: Log to not writable log path"
+      end
+
+      it "amends in memory log to stdout" do
+        expect(output).to include "[ERROR] appsignal: Log in memory"
+      end
+
+      it "outputs a warning" do
+        expect(output).to include \
+          "appsignal: Unable to log to '#{log_path}' "\
+          "or the '#{Appsignal::Config.system_tmp_dir}' fallback."
+      end
+    end
+
+    context "when on Heroku" do
+      before do
+        capture_stdout(out_stream) do
+          initialize_config
+          Appsignal.start_logger
+          Appsignal.logger.error("Log to stdout")
+        end
+      end
+      around { |example| recognize_as_heroku { example.run } }
+
+      it "logs to stdout" do
+        expect(output).to include "[ERROR] appsignal: Log to stdout"
+      end
+
+      it "amends in memory log to stdout" do
+        expect(output).to include "[ERROR] appsignal: Log in memory"
+      end
+    end
+
+    describe "#logger#level" do
+      subject { Appsignal.logger.level }
+
+      context "when there is no config" do
+        before do
+          Appsignal.config = nil
+          capture_stdout(out_stream) do
+            Appsignal.start_logger
+          end
+        end
+
+        it "sets the log level to info" do
+          expect(subject).to eq Logger::INFO
+        end
+      end
+
+      context "when there is a config" do
+        context "when log level is configured to debug" do
+          before do
+            capture_stdout(out_stream) do
+              initialize_config
+              Appsignal.config[:debug] = true
+              Appsignal.start_logger
+            end
+          end
+
+          it "sets the log level to debug" do
+            expect(subject).to eq Logger::DEBUG
+          end
+        end
+      end
+    end
+  end
 end

data/spec/support/helpers/std_streams_helper.rb

@@ -49,18 +49,25 @@ module StdStreamsHelper
     stderr.unlink
   end
 
-  def silence
-    std_stream = Tempfile.new(SecureRandom.uuid)
-    original_stdout = $stdout.dup
-    original_stderr = $stderr.dup
-    $stdout.reopen std_stream
-    $stderr.reopen std_stream
-
-    yield
+  # Silence the STDOUT.
+  #
+  # Ignore the STDOUT and don't print it in the test suite's STDOUT.
+  #
+  # If an error is found the output the output is raised as an error, failing
+  # the spec. Warnings and other AppSignal messages are ignored.
+  #
+  # Usage
+  #
+  #     silence { do_something }
+  #
+  #     silence { puts "ERROR!" }
+  #     # => Error found in silenced output:
+  #     # ERROR!
+  def silence(&block)
+    stream = Tempfile.new(SecureRandom.uuid)
+    capture_std_streams(stream, stream, &block)
   ensure
-    $stdout.reopen original_stdout
-    $stderr.reopen original_stderr
-    std_stream.rewind
-    std_stream.unlink
+    output = stream.read
+    raise "Error found in silenced output:\n#{output}" if output =~ /(ERR|Error|error)/
   end
 end

data/spec/support/project_fixture/config/appsignal.yml

@@ -1,6 +1,13 @@
 default: &defaults
   push_api_key: "abc"
   name: "TestApp"
+  request_headers: [
+    "HTTP_ACCEPT", "HTTP_ACCEPT_CHARSET", "HTTP_ACCEPT_ENCODING",
+    "HTTP_ACCEPT_LANGUAGE", "HTTP_CACHE_CONTROL", "HTTP_CONNECTION",
+    "CONTENT_LENGTH", "PATH_INFO", "HTTP_RANGE", "HTTP_REFERER",
+    "REQUEST_METHOD", "REQUEST_URI", "SERVER_NAME", "SERVER_PORT",
+    "SERVER_PROTOCOL", "HTTP_USER_AGENT"
+  ]
 
 production:
   <<: *defaults
@@ -21,6 +28,13 @@ old_config:
   active: true
   ignore_exceptions:
     - StandardError
+  request_headers: [
+    "HTTP_ACCEPT", "HTTP_ACCEPT_CHARSET", "HTTP_ACCEPT_ENCODING",
+    "HTTP_ACCEPT_LANGUAGE", "HTTP_CACHE_CONTROL", "HTTP_CONNECTION",
+    "CONTENT_LENGTH", "PATH_INFO", "HTTP_RANGE", "HTTP_REFERER",
+    "REQUEST_METHOD", "REQUEST_URI", "SERVER_NAME", "SERVER_PORT",
+    "SERVER_PROTOCOL", "HTTP_USER_AGENT"
+  ]
 
 old_config_mixed_with_new_config:
   push_api_key: "ghi"
@@ -30,3 +44,10 @@ old_config_mixed_with_new_config:
     - NoMethodError
   ignore_exceptions:
     - StandardError
+  request_headers: [
+    "HTTP_ACCEPT", "HTTP_ACCEPT_CHARSET", "HTTP_ACCEPT_ENCODING",
+    "HTTP_ACCEPT_LANGUAGE", "HTTP_CACHE_CONTROL", "HTTP_CONNECTION",
+    "CONTENT_LENGTH", "PATH_INFO", "HTTP_RANGE", "HTTP_REFERER",
+    "REQUEST_METHOD", "REQUEST_URI", "SERVER_NAME", "SERVER_PORT",
+    "SERVER_PROTOCOL", "HTTP_USER_AGENT"
+  ]