appsignal 2.11.0.beta.5-java → 2.11.3-java

data/spec/lib/appsignal/hooks/resque_spec.rb

@@ -60,7 +60,10 @@ describe Appsignal::Hooks::ResqueHook do
           "error" => nil,
           "namespace" => namespace,
           "metadata" => {},
-          "sample_data" => { "tags" => { "queue" => queue } }
+          "sample_data" => {
+            "breadcrumbs" => [],
+            "tags" => { "queue" => queue }
+          }
         )
         expect(transaction_hash["events"].map { |e| e["name"] })
           .to eql(["perform.resque"])
@@ -84,7 +87,10 @@ describe Appsignal::Hooks::ResqueHook do
             },
             "namespace" => namespace,
             "metadata" => {},
-            "sample_data" => { "tags" => { "queue" => queue } }
+            "sample_data" => {
+              "breadcrumbs" => [],
+              "tags" => { "queue" => queue }
+            }
           )
         end
       end
@@ -118,6 +124,7 @@ describe Appsignal::Hooks::ResqueHook do
             "metadata" => {},
             "sample_data" => {
               "tags" => { "queue" => queue },
+              "breadcrumbs" => [],
               "params" => [
                 "foo",
                 {
@@ -174,6 +181,7 @@ describe Appsignal::Hooks::ResqueHook do
             "namespace" => namespace,
             "metadata" => {},
             "sample_data" => {
+              "breadcrumbs" => [],
               "tags" => { "queue" => queue }
               # Params will be set by the ActiveJob integration
             }

data/spec/lib/appsignal/hooks/shoryuken_spec.rb

@@ -1,55 +1,73 @@
 describe Appsignal::Hooks::ShoryukenMiddleware do
-  let(:current_transaction) { background_job_transaction }
-
   class DemoShoryukenWorker
   end
 
+  let(:time) { "2010-01-01 10:01:00UTC" }
   let(:worker_instance) { DemoShoryukenWorker.new }
-  let(:queue) { double }
-  let(:sqs_msg) { double(:attributes => {}) }
+  let(:queue) { "some-funky-queue-name" }
+  let(:sqs_msg) { double(:message_id => "msg1", :attributes => {}) }
   let(:body) { {} }
-
-  before do
-    allow(Appsignal::Transaction).to receive(:current).and_return(current_transaction)
-    start_agent
+  before(:context) { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  def perform_job(&block)
+    block ||= lambda {}
+    Timecop.freeze(Time.parse(time)) do
+      Appsignal::Hooks::ShoryukenMiddleware.new.call(
+        worker_instance,
+        queue,
+        sqs_msg,
+        body,
+        &block
+      )
+    end
   end
 
   context "with a performance call" do
-    let(:queue) { "some-funky-queue-name" }
+    let(:sent_timestamp) { Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 }
     let(:sqs_msg) do
-      double(:attributes => { "SentTimestamp" => Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 })
+      double(:message_id => "msg1", :attributes => { "SentTimestamp" => sent_timestamp })
     end
 
     context "with complex argument" do
-      let(:body) do
-        {
-          :foo => "Foo",
-          :bar => "Bar"
-        }
-      end
-      after do
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
-      end
+      let(:body) { { :foo => "Foo", :bar => "Bar" } }
 
       it "wraps the job in a transaction with the correct params" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => {
-            :foo => "Foo",
-            :bar => "Bar"
-          },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
+        allow_any_instance_of(Appsignal::Transaction).to receive(:set_queue_start).and_call_original
+        expect { perform_job }.to change { created_transactions.length }.by(1)
+
+        transaction = last_transaction
+        expect(transaction).to be_completed
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "DemoShoryukenWorker#perform",
+          "id" => kind_of(String), # AppSignal generated id
+          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+          "error" => nil
         )
+        expect(transaction_hash["events"].first).to include(
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "gc_duration" => kind_of(Float),
+          "start" => kind_of(Float),
+          "duration" => kind_of(Float),
+          "name" => "perform_job.shoryuken",
+          "title" => ""
+        )
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "foo" => "Foo", "bar" => "Bar" },
+          "metadata" => {
+            "message_id" => "msg1",
+            "queue" => queue,
+            "SentTimestamp" => sent_timestamp
+          }
+        )
+        expect(transaction).to have_received(:set_queue_start).with(sent_timestamp)
       end
 
       context "with parameter filtering" do
@@ -57,21 +75,16 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
           Appsignal.config = project_fixture_config("production")
           Appsignal.config[:filter_parameters] = ["foo"]
         end
+        after do
+          Appsignal.config[:filter_parameters] = []
+        end
 
         it "filters selected arguments" do
-          expect(Appsignal).to receive(:monitor_transaction).with(
-            "perform_job.shoryuken",
-            :class => "DemoShoryukenWorker",
-            :method => "perform",
-            :metadata => {
-              :queue => "some-funky-queue-name",
-              "SentTimestamp" => 217_123_200_000
-            },
-            :params => {
-              :foo => "[FILTERED]",
-              :bar => "Bar"
-            },
-            :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
+          perform_job
+
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash["sample_data"]).to include(
+            "params" => { "foo" => "[FILTERED]", "bar" => "Bar" }
           )
         end
       end
@@ -81,23 +94,12 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       let(:body) { "foo bar" }
 
       it "handles string arguments" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => { :params => body },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
-        )
+        perform_job
 
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
+        transaction_hash = last_transaction.to_h
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "params" => body }
+        )
       end
     end
 
@@ -105,58 +107,103 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       let(:body) { 1 }
 
       it "handles primitive types as arguments" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => { :params => body },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
-        )
+        perform_job
 
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
+        transaction_hash = last_transaction.to_h
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "params" => body }
+        )
       end
     end
   end
 
   context "with exception" do
-    let(:transaction) do
-      Appsignal::Transaction.new(
-        SecureRandom.uuid,
-        Appsignal::Transaction::BACKGROUND_JOB,
-        Appsignal::Transaction::GenericRequest.new({})
+    it "sets the exception on the transaction" do
+      expect do
+        expect do
+          perform_job { raise ExampleException, "error message" }
+        end.to raise_error(ExampleException)
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to be_completed
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "DemoShoryukenWorker#perform",
+        "id" => kind_of(String), # AppSignal generated id
+        "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+        "error" => {
+          "name" => "ExampleException",
+          "message" => "error message",
+          "backtrace" => kind_of(String)
+        }
       )
     end
+  end
 
-    before do
-      allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-      expect(Appsignal::Transaction).to receive(:create)
-        .with(
-          kind_of(String),
-          Appsignal::Transaction::BACKGROUND_JOB,
-          kind_of(Appsignal::Transaction::GenericRequest)
-        ).and_return(transaction)
+  context "with batched jobs" do
+    let(:sqs_msg) do
+      [
+        double(
+          :message_id => "msg2",
+          :attributes => { "SentTimestamp" => (Time.parse("1976-11-18 01:00:00UTC").to_i * 1000).to_s }
+        ),
+        double(
+          :message_id => "msg1",
+          :attributes => { "SentTimestamp" => sent_timestamp.to_s }
+        )
+      ]
     end
-
-    it "sets the exception on the transaction" do
-      expect(transaction).to receive(:set_error).with(ExampleException)
+    let(:body) do
+      [
+        "foo bar",
+        { :id => "123", :foo => "Foo", :bar => "Bar" }
+      ]
     end
+    let(:sent_timestamp) { Time.parse("1976-11-18 01:00:00UTC").to_i * 1000 }
 
-    after do
+    it "creates a transaction for the batch" do
+      allow_any_instance_of(Appsignal::Transaction).to receive(:set_queue_start).and_call_original
       expect do
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            raise ExampleException
-          end
-        end
-      end.to raise_error(ExampleException)
+        perform_job {}
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to be_completed
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "DemoShoryukenWorker#perform",
+        "id" => kind_of(String), # AppSignal generated id
+        "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+        "error" => nil
+      )
+      expect(transaction_hash["events"].first).to include(
+        "allocation_count" => kind_of(Integer),
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "gc_duration" => kind_of(Float),
+        "start" => kind_of(Float),
+        "duration" => kind_of(Float),
+        "name" => "perform_job.shoryuken",
+        "title" => ""
+      )
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => {
+          "msg2" => "foo bar",
+          "msg1" => { "id" => "123", "foo" => "Foo", "bar" => "Bar" }
+        },
+        "metadata" => {
+          "batch" => true,
+          "queue" => "some-funky-queue-name",
+          "SentTimestamp" => sent_timestamp.to_s # Earliest/oldest timestamp from messages
+        }
+      )
+      # Queue time based on earliest/oldest timestamp from messages
+      expect(transaction).to have_received(:set_queue_start).with(sent_timestamp)
     end
   end
 end

data/spec/lib/appsignal/hooks/sidekiq_spec.rb

@@ -262,7 +262,8 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
         "sample_data" => {
           "environment" => {},
           "params" => expected_args,
-          "tags" => {}
+          "tags" => {},
+          "breadcrumbs" => []
         }
       )
       expect_transaction_to_have_sidekiq_event(transaction_hash)
@@ -290,7 +291,8 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
         "sample_data" => {
           "environment" => {},
           "params" => expected_args,
-          "tags" => {}
+          "tags" => {},
+          "breadcrumbs" => []
         }
       )
       # TODO: Not available in transaction.to_h yet.

data/spec/lib/appsignal/transaction_spec.rb

@@ -356,6 +356,57 @@ describe Appsignal::Transaction do
       end
     end
 
+    describe "#add_breadcrumb" do
+      context "when over the limit" do
+        before do
+          22.times do |i|
+            transaction.add_breadcrumb(
+              "network",
+              "GET http://localhost",
+              "User made external network request",
+              { :code => i + 1 },
+              Time.parse("10-10-2010 10:00:00 UTC")
+            )
+          end
+          transaction.sample_data
+        end
+
+        it "stores last <LIMIT> breadcrumbs on the transaction" do
+          expect(transaction.to_h["sample_data"]["breadcrumbs"].length).to eql(20)
+          expect(transaction.to_h["sample_data"]["breadcrumbs"][0]).to eq(
+            "action" => "GET http://localhost",
+            "category" => "network",
+            "message" => "User made external network request",
+            "metadata" => { "code" => 3 },
+            "time" => 1286704800 # rubocop:disable Style/NumericLiterals
+          )
+          expect(transaction.to_h["sample_data"]["breadcrumbs"][19]).to eq(
+            "action" => "GET http://localhost",
+            "category" => "network",
+            "message" => "User made external network request",
+            "metadata" => { "code" => 22 },
+            "time" => 1286704800 # rubocop:disable Style/NumericLiterals
+          )
+        end
+      end
+
+      context "with defaults" do
+        it "stores breadcrumb with defaults on transaction" do
+          timeframe_start = Time.now.utc.to_i
+          transaction.add_breadcrumb("user_action", "clicked HOME")
+          transaction.sample_data
+          timeframe_end = Time.now.utc.to_i
+
+          breadcrumb = transaction.to_h["sample_data"]["breadcrumbs"][0]
+          expect(breadcrumb["category"]).to eq("user_action")
+          expect(breadcrumb["action"]).to eq("clicked HOME")
+          expect(breadcrumb["message"]).to eq("")
+          expect(breadcrumb["time"]).to be_between(timeframe_start, timeframe_end)
+          expect(breadcrumb["metadata"]).to eq({})
+        end
+      end
+    end
+
     describe "#set_action" do
       context "when the action is set" do
         it "updates the action name on the transaction" do
@@ -649,6 +700,10 @@ describe Appsignal::Transaction do
           "tags",
           Appsignal::Utils::Data.generate({})
         ).once
+        expect(transaction.ext).to receive(:set_sample_data).with(
+          "breadcrumbs",
+          Appsignal::Utils::Data.generate([])
+        ).once
 
         transaction.sample_data
       end

data/spec/lib/appsignal_spec.rb

@@ -491,6 +491,36 @@ describe Appsignal do
       end
     end
 
+    describe ".add_breadcrumb" do
+      before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
+
+      context "with transaction" do
+        let(:transaction) { double }
+        it "should call add_breadcrumb on transaction" do
+          expect(transaction).to receive(:add_breadcrumb)
+            .with("Network", "http", "User made network request", { :response => 200 }, fixed_time)
+        end
+
+        after do
+          Appsignal.add_breadcrumb(
+            "Network",
+            "http",
+            "User made network request",
+            { :response => 200 },
+            fixed_time
+          )
+        end
+      end
+
+      context "without transaction" do
+        let(:transaction) { nil }
+
+        it "should not call add_breadcrumb on transaction" do
+          expect(Appsignal.add_breadcrumb("Network", "http")).to be_falsy
+        end
+      end
+    end
+
     describe "custom stats" do
       let(:tags) { { :foo => "bar" } }