appsignal 2.5.0.alpha.1-java

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

@@ -0,0 +1,73 @@
+if DependencyHelper.sinatra_present?
+  require "appsignal/integrations/sinatra"
+
+  def install_sinatra_integration
+    load File.expand_path("lib/appsignal/integrations/sinatra.rb", project_dir)
+  end
+
+  # "Uninstall" the AppSignal integration
+  def uninstall_sinatra_integration
+    Sinatra::Base.instance_variable_get(:@middleware).delete_if do |middleware|
+      middleware.first == Appsignal::Rack::SinatraBaseInstrumentation
+    end
+  end
+
+  describe "Sinatra integration" do
+    before { allow(Appsignal).to receive(:active?).and_return(true) }
+    after { uninstall_sinatra_integration }
+
+    context "Appsignal.logger" do
+      subject { Appsignal.logger }
+
+      it "sets a logger" do
+        install_sinatra_integration
+        is_expected.to be_a Logger
+      end
+    end
+
+    describe "middleware" do
+      context "when AppSignal is not active" do
+        before { allow(Appsignal).to receive(:active?).and_return(false) }
+
+        it "does not add the instrumentation middleware to Sinatra::Base" do
+          install_sinatra_integration
+          expect(Sinatra::Base.middleware.to_a).to_not include(
+            [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
+          )
+        end
+      end
+
+      context "when AppSignal is active" do
+        it "adds the instrumentation middleware to Sinatra::Base" do
+          install_sinatra_integration
+          expect(Sinatra::Base.middleware.to_a).to include(
+            [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
+          )
+        end
+      end
+    end
+
+    describe "environment" do
+      subject { Appsignal.config.env }
+
+      context "without APPSIGNAL_APP_ENV" do
+        before { install_sinatra_integration }
+
+        it "uses the app environment" do
+          expect(subject).to eq("test")
+        end
+      end
+
+      context "with APPSIGNAL_APP_ENV" do
+        before do
+          ENV["APPSIGNAL_APP_ENV"] = "env-staging"
+          install_sinatra_integration
+        end
+
+        it "uses the environment variable" do
+          expect(subject).to eq("env-staging")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+if DependencyHelper.webmachine_present?
+  require "appsignal/integrations/webmachine"
+
+  describe Appsignal::Integrations::WebmachinePlugin::FSM do
+    let(:request) do
+      Webmachine::Request.new("GET", "http://google.com:80/foo", {}, nil)
+    end
+    let(:resource)    { double(:trace? => false, :handle_exception => true) }
+    let(:response)    { double }
+    let(:transaction) { double(:set_action_if_nil => true) }
+    let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
+    before(:context) { start_agent }
+
+    # Make sure the request responds to the method we need to get query params.
+    describe "request" do
+      it "should respond to `query`" do
+        expect(request).to respond_to(:query)
+      end
+    end
+
+    describe "#run_with_appsignal" do
+      before do
+        allow(fsm).to receive(:request).and_return(request)
+        allow(fsm).to receive(:run_without_appsignal).and_return(true)
+        allow(SecureRandom).to receive(:uuid).and_return("uuid")
+        allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
+      end
+
+      it "should create a transaction" do
+        expect(Appsignal::Transaction).to receive(:create).with(
+          "uuid",
+          Appsignal::Transaction::HTTP_REQUEST,
+          request,
+          :params_method => :query
+        ).and_return(transaction)
+      end
+
+      it "should set the action" do
+        expect(transaction).to receive(:set_action_if_nil).with("RSpec::Mocks::Double#GET")
+      end
+
+      it "should call the original method" do
+        expect(fsm).to receive(:run_without_appsignal)
+      end
+
+      it "should instrument the original method" do
+        expect(Appsignal).to receive(:instrument).with("process_action.webmachine")
+      end
+
+      it "should close the transaction" do
+        expect(Appsignal::Transaction).to receive(:complete_current!)
+      end
+
+      after { fsm.run }
+    end
+
+    describe "#handle_exceptions_with_appsignal" do
+      let(:error) { ExampleException }
+
+      it "should catch the error and send it to AppSignal" do
+        expect(Appsignal).to receive(:set_error).with(error)
+      end
+
+      after do
+        fsm.send(:handle_exceptions) { raise error }
+      end
+    end
+  end
+end

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -0,0 +1,128 @@
+describe Appsignal::JSExceptionTransaction do
+  before { allow(SecureRandom).to receive(:uuid).and_return("123abc") }
+
+  let!(:transaction) { Appsignal::JSExceptionTransaction.new(data) }
+  let(:data) do
+    {
+      "name"        => "TypeError",
+      "message"     => "foo is not a valid method",
+      "action"      => "ExceptionIncidentComponent",
+      "path"        => "foo.bar/moo",
+      "environment" => "development",
+      "backtrace"   => [
+        "foo.bar/js:11:1",
+        "foo.bar/js:22:2"
+      ],
+      "tags" => [
+        "tag1"
+      ]
+    }
+  end
+
+  describe "#initialize" do
+    it "should call all required methods" do
+      expect(Appsignal::Extension).to receive(:start_transaction).with("123abc", "frontend", 0).and_return(1)
+
+      expect(transaction).to receive(:set_action)
+      expect(transaction).to receive(:set_metadata)
+      expect(transaction).to receive(:set_error)
+      expect(transaction).to receive(:set_sample_data)
+
+      transaction.send :initialize, data
+
+      expect(transaction.ext).to_not be_nil
+    end
+  end
+
+  describe "#set_action" do
+    it "should call `Appsignal::Extension.set_action`" do
+      expect(transaction.ext).to receive(:set_action).with(
+        "ExceptionIncidentComponent"
+      )
+
+      transaction.set_action
+    end
+  end
+
+  describe "#set_metadata" do
+    it "should call `Appsignal::Extension.set_transaction_metadata`" do
+      expect(transaction.ext).to receive(:set_metadata).with(
+        "path",
+        "foo.bar/moo"
+      )
+
+      transaction.set_metadata
+    end
+  end
+
+  describe "#set_error" do
+    it "should call `Appsignal::Extension.set_transaction_error`" do
+      expect(transaction.ext).to receive(:set_error).with(
+        "TypeError",
+        "foo is not a valid method",
+        Appsignal::Utils.data_generate(["foo.bar/js:11:1", "foo.bar/js:22:2"])
+      )
+
+      transaction.set_error
+    end
+  end
+
+  describe "#set_sample_data" do
+    it "should call `Appsignal::Extension.set_transaction_error_data`" do
+      expect(transaction.ext).to receive(:set_sample_data).with(
+        "tags",
+        Appsignal::Utils.data_generate(["tag1"])
+      )
+
+      transaction.set_sample_data
+    end
+  end
+
+  context "when sending just the name" do
+    let(:data) { { "name" => "TypeError" } }
+
+    describe "#set_action" do
+      it "should not call `Appsignal::Extension.set_action`" do
+        expect(transaction.ext).to_not receive(:set_action)
+
+        transaction.set_action
+      end
+    end
+
+    describe "#set_metadata" do
+      it "should not call `Appsignal::Extension.set_transaction_metadata`" do
+        expect(transaction.ext).to_not receive(:set_metadata)
+
+        transaction.set_metadata
+      end
+    end
+
+    describe "#set_error" do
+      it "should call `Appsignal::Extension.set_transaction_error` with just the name" do
+        expect(transaction.ext).to receive(:set_error).with(
+          "TypeError",
+          "",
+          Appsignal::Utils.data_generate([])
+        )
+
+        transaction.set_error
+      end
+    end
+
+    describe "#set_sample_data" do
+      it "should not call `Appsignal::Extension.set_transaction_error_data`" do
+        expect(transaction.ext).to_not receive(:set_sample_data)
+
+        transaction.set_sample_data
+      end
+    end
+  end
+
+  describe "#complete!" do
+    it "should call all required methods" do
+      expect(transaction.ext).to receive(:finish).and_call_original
+      expect(transaction.ext).to receive(:complete).and_call_original
+      transaction.complete!
+    end
+  end
+end

data/spec/lib/appsignal/marker_spec.rb

@@ -0,0 +1,51 @@
+describe Appsignal::Marker do
+  let(:config) { project_fixture_config }
+  let(:marker) do
+    described_class.new(
+      {
+        :revision => "503ce0923ed177a3ce000005",
+        :repository => "master",
+        :user => "batman",
+        :rails_env => "production"
+      },
+      config
+    )
+  end
+  let(:out_stream) { std_stream }
+  let(:output) { out_stream.read }
+
+  describe "#transmit" do
+    def stub_marker_request
+      stub_api_request config, "markers", marker.marker_data
+    end
+
+    def run
+      capture_stdout(out_stream) { marker.transmit }
+    end
+
+    context "when request is valid" do
+      before { stub_marker_request.to_return(:status => 200) }
+
+      it "outputs success" do
+        run
+        expect(output).to include \
+          "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman",
+          "AppSignal has been notified of this deploy!"
+      end
+    end
+
+    context "when request is invalid" do
+      before { stub_marker_request.to_return(:status => 500) }
+
+      it "outputs failure" do
+        run
+        expect(output).to include \
+          "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman",
+          "Something went wrong while trying to notify AppSignal: 500 at "\
+          "#{config[:endpoint]}/1/markers"
+        expect(output).to_not include \
+          "AppSignal has been notified of this deploy!"
+      end
+    end
+  end
+end

data/spec/lib/appsignal/minutely_spec.rb

@@ -0,0 +1,50 @@
+describe Appsignal::Minutely do
+  before do
+    Appsignal::Minutely.probes.clear
+  end
+
+  it "should have a list of probes" do
+    expect(Appsignal::Minutely.probes).to be_instance_of(Array)
+  end
+
+  describe ".start" do
+    it "should call the probes periodically" do
+      probe = double
+      expect(probe).to receive(:call).at_least(:twice)
+      Appsignal::Minutely.probes << probe
+      allow(Appsignal::Minutely).to receive(:wait_time).and_return(0.1)
+
+      Appsignal::Minutely.start
+
+      sleep 0.5
+    end
+  end
+
+  describe ".wait_time" do
+    it "should get the time to the next minute" do
+      allow_any_instance_of(Time).to receive(:sec).and_return(30)
+      expect(Appsignal::Minutely.wait_time).to eq 30
+    end
+  end
+
+  describe ".add_gc_probe" do
+    it "should add the gc probe to the list" do
+      expect(Appsignal::Minutely.probes).to be_empty
+
+      Appsignal::Minutely.add_gc_probe
+
+      expect(Appsignal::Minutely.probes.size).to eq(1)
+      expect(Appsignal::Minutely.probes[0]).to be_instance_of(Appsignal::Minutely::GCProbe)
+    end
+  end
+
+  describe Appsignal::Minutely::GCProbe do
+    describe "#call" do
+      it "should collect GC metrics" do
+        expect(Appsignal).to receive(:set_process_gauge).at_least(8).times
+
+        Appsignal::Minutely::GCProbe.new.call
+      end
+    end
+  end
+end

data/spec/lib/appsignal/rack/generic_instrumentation_spec.rb

@@ -0,0 +1,90 @@
+describe Appsignal::Rack::GenericInstrumentation do
+  before :context do
+    start_agent
+  end
+
+  let(:app) { double(:call => true) }
+  let(:env) { { :path => "/", :method => "GET" } }
+  let(:options) { {} }
+  let(:middleware) { Appsignal::Rack::GenericInstrumentation.new(app, options) }
+
+  describe "#call" do
+    before do
+      allow(middleware).to receive(:raw_payload).and_return({})
+    end
+
+    context "when appsignal is active" do
+      before { allow(Appsignal).to receive(:active?).and_return(true) }
+
+      it "should call with monitoring" do
+        expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
+      end
+    end
+
+    context "when appsignal is not active" do
+      before { allow(Appsignal).to receive(:active?).and_return(false) }
+
+      it "should not call with monitoring" do
+        expect(middleware).to_not receive(:call_with_appsignal_monitoring)
+      end
+
+      it "should call the stack" do
+        expect(app).to receive(:call).with(env)
+      end
+    end
+
+    after { middleware.call(env) }
+  end
+
+  describe "#call_with_appsignal_monitoring", :error => false do
+    it "should create a transaction" do
+      expect(Appsignal::Transaction).to receive(:create).with(
+        kind_of(String),
+        Appsignal::Transaction::HTTP_REQUEST,
+        kind_of(Rack::Request)
+      ).and_return(double(:set_action_if_nil => nil, :set_http_or_background_queue_start => nil, :set_metadata => nil))
+    end
+
+    it "should call the app" do
+      expect(app).to receive(:call).with(env)
+    end
+
+    context "with an exception", :error => true do
+      let(:error) { ExampleException }
+      let(:app) do
+        double.tap do |d|
+          allow(d).to receive(:call).and_raise(error)
+        end
+      end
+
+      it "records the exception" do
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
+      end
+    end
+
+    it "should set the action to unknown" do
+      expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("unknown")
+    end
+
+    context "with a route specified in the env" do
+      before do
+        env["appsignal.route"] = "GET /"
+      end
+
+      it "should set the action" do
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("GET /")
+      end
+    end
+
+    it "should set metadata" do
+      expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
+    end
+
+    it "should set the queue start" do
+      expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
+    end
+
+    after(:error => false) { middleware.call(env) }
+    after(:error => true) { expect { middleware.call(env) }.to raise_error(error) }
+  end
+end