appsignal 2.5.0.alpha.1-java

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

@@ -0,0 +1,35 @@
+describe Appsignal::Hooks::WebmachineHook do
+  if DependencyHelper.webmachine_present?
+    context "with webmachine" do
+      let(:fsm) { Webmachine::Decision::FSM.new(double(:trace? => false), double, double) }
+      before(:context) { start_agent }
+
+      describe "#dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it { is_expected.to be_truthy }
+      end
+
+      it "should include the run alias methods" do
+        expect(fsm).to respond_to(:run_with_appsignal)
+        expect(fsm).to respond_to(:run_without_appsignal)
+      end
+
+      it "should include the handle_exceptions alias methods" do
+        expect(
+          fsm.respond_to?(:handle_exceptions_with_appsignal, true)
+        ).to be_truthy
+
+        expect(
+          fsm.respond_to?(:handle_exceptions_without_appsignal, true)
+        ).to be_truthy
+      end
+    end
+  else
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

data/spec/lib/appsignal/hooks_spec.rb

@@ -0,0 +1,195 @@
+class MockPresentHook < Appsignal::Hooks::Hook
+  def dependencies_present?
+    true
+  end
+
+  def install
+    MockPresentHook.call_something
+  end
+
+  def self.call_something
+  end
+end
+
+class MockNotPresentHook < Appsignal::Hooks::Hook
+  def dependencies_present?
+    false
+  end
+
+  def install
+    MockNotPresentHook.call_something
+  end
+end
+
+class MockErrorHook < Appsignal::Hooks::Hook
+  def dependencies_present?
+    true
+  end
+
+  def install
+    raise "error"
+  end
+end
+
+describe Appsignal::Hooks do
+  it "should register and install a hook once" do
+    Appsignal::Hooks::Hook.register(:mock_present_hook, MockPresentHook)
+
+    expect(Appsignal::Hooks.hooks[:mock_present_hook]).to be_instance_of(MockPresentHook)
+    expect(Appsignal::Hooks.hooks[:mock_present_hook].installed?).to be_falsy
+
+    expect(MockPresentHook).to receive(:call_something).once
+
+    Appsignal::Hooks.load_hooks
+    Appsignal::Hooks.load_hooks
+    Appsignal::Hooks.load_hooks
+    expect(Appsignal::Hooks.hooks[:mock_present_hook].installed?).to be_truthy
+    Appsignal::Hooks.hooks.delete(:mock_present_hook)
+  end
+
+  it "should not install if depencies are not present" do
+    Appsignal::Hooks::Hook.register(:mock_not_present_hook, MockNotPresentHook)
+
+    expect(Appsignal::Hooks.hooks[:mock_not_present_hook]).to be_instance_of(MockNotPresentHook)
+    expect(Appsignal::Hooks.hooks[:mock_not_present_hook].installed?).to be_falsy
+
+    expect(MockPresentHook).to_not receive(:call_something)
+
+    Appsignal::Hooks.load_hooks
+
+    expect(Appsignal::Hooks.hooks[:mock_not_present_hook].installed?).to be_falsy
+    Appsignal::Hooks.hooks.delete(:mock_not_present_hook)
+  end
+
+  it "should not install if there is an error while installing" do
+    Appsignal::Hooks::Hook.register(:mock_error_hook, MockErrorHook)
+
+    expect(Appsignal::Hooks.hooks[:mock_error_hook]).to be_instance_of(MockErrorHook)
+    expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
+
+    expect(Appsignal.logger).to receive(:error).with("Error while installing mock_error_hook hook: error").once
+
+    Appsignal::Hooks.load_hooks
+
+    expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
+    Appsignal::Hooks.hooks.delete(:mock_error_hook)
+  end
+end
+
+describe Appsignal::Hooks::Helpers do
+  class ClassWithHelpers
+    include Appsignal::Hooks::Helpers
+  end
+  let(:with_helpers) { ClassWithHelpers.new }
+
+  describe "#truncate" do
+    let(:very_long_text) do
+      "a" * 400
+    end
+
+    it "should truncate the text to 200 chars max" do
+      expect(with_helpers.truncate(very_long_text)).to eq "#{"a" * 197}..."
+    end
+  end
+
+  describe "#string_or_inspect" do
+    context "when string" do
+      it "should return the string" do
+        expect(with_helpers.string_or_inspect("foo")).to eq "foo"
+      end
+    end
+
+    context "when integer" do
+      it "should return the string" do
+        expect(with_helpers.string_or_inspect(1)).to eq "1"
+      end
+    end
+
+    context "when object" do
+      let(:object) { Object.new }
+
+      it "should return the string" do
+        expect(with_helpers.string_or_inspect(object)).to eq object.inspect
+      end
+    end
+  end
+
+  describe "#extract_value" do
+    context "for a hash" do
+      let(:hash) { { :key => "value" } }
+
+      context "when the key exists" do
+        subject { with_helpers.extract_value(hash, :key) }
+
+        it { is_expected.to eq "value" }
+      end
+
+      context "when the key does not exist" do
+        subject { with_helpers.extract_value(hash, :nonexistent_key) }
+
+        it { is_expected.to be_nil }
+
+        context "with a default value" do
+          subject { with_helpers.extract_value(hash, :nonexistent_key, 1) }
+
+          it { is_expected.to eq 1 }
+        end
+      end
+    end
+
+    context "for a struct" do
+      before :context do
+        TestStruct = Struct.new(:key)
+      end
+      let(:struct) { TestStruct.new("value") }
+
+      context "when the key exists" do
+        subject { with_helpers.extract_value(struct, :key) }
+
+        it { is_expected.to eq "value" }
+      end
+
+      context "when the key does not exist" do
+        subject { with_helpers.extract_value(struct, :nonexistent_key) }
+
+        it { is_expected.to be_nil }
+
+        context "with a default value" do
+          subject { with_helpers.extract_value(struct, :nonexistent_key, 1) }
+
+          it { is_expected.to eq 1 }
+        end
+      end
+    end
+
+    context "for an object" do
+      let(:object) { double(:existing_method => "value") }
+
+      context "when the method exists" do
+        subject { with_helpers.extract_value(object, :existing_method) }
+
+        it { is_expected.to eq "value" }
+      end
+
+      context "when the method does not exist" do
+        subject { with_helpers.extract_value(object, :nonexistent_method) }
+
+        it { is_expected.to be_nil }
+
+        context "and there is a default value" do
+          subject { with_helpers.extract_value(object, :nonexistent_method, 1) }
+
+          it { is_expected.to eq 1 }
+        end
+      end
+    end
+
+    context "when we need to call to_s on the value" do
+      let(:object) { double(:existing_method => 1) }
+
+      subject { with_helpers.extract_value(object, :existing_method, nil, true) }
+
+      it { is_expected.to eq "1" }
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require "appsignal/integrations/data_mapper"
+
+describe Appsignal::Hooks::DataMapperLogListener do
+  module DataMapperLog
+    def log(message)
+    end
+  end
+
+  describe "#log" do
+    let(:transaction) { double }
+    let(:message) do
+      double(
+        :query    => "SELECT * from users",
+        :duration => 100
+      )
+    end
+    let(:connection_class) do
+      module DataObjects
+        module Sqlite3
+          class Connection
+            include DataMapperLog
+            include Appsignal::Hooks::DataMapperLogListener
+          end
+        end
+      end
+    end
+
+    before { allow(Appsignal::Transaction).to receive(:current) { transaction } }
+
+    it "should record the log entry in an event" do
+      expect(transaction).to receive(:record_event).with(
+        "query.data_mapper",
+        "DataMapper Query",
+        "SELECT * from users",
+        100,
+        Appsignal::EventFormatter::SQL_BODY_FORMAT
+      )
+    end
+
+    context "when scheme is not sql-like" do
+      let(:connection_class) do
+        module DataObjects
+          module MongoDB
+            class Connection
+              include DataMapperLog
+              include Appsignal::Hooks::DataMapperLogListener
+            end
+          end
+        end
+      end
+
+      it "should record the log entry in an event without body" do
+        expect(transaction).to receive(:record_event).with(
+          "query.data_mapper",
+          "DataMapper Query",
+          "",
+          100,
+          Appsignal::EventFormatter::DEFAULT
+        )
+      end
+    end
+
+    after { connection_class.new.log(message) }
+  end
+end

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

@@ -0,0 +1,225 @@
+if DependencyHelper.grape_present?
+  require "appsignal/integrations/grape"
+
+  describe Appsignal::Grape::Middleware do
+    let(:app) do
+      Class.new(::Grape::API) do
+        format :json
+        post :ping do
+          { :message => "Hello world!" }
+        end
+      end
+    end
+    let(:api_endpoint) { app.endpoints.first }
+    let(:env) do
+      http_request_env_with_data \
+        "api.endpoint" => api_endpoint,
+        "REQUEST_METHOD" => "POST",
+        :path => "/ping"
+    end
+    let(:middleware) { Appsignal::Grape::Middleware.new(api_endpoint) }
+    around do |example|
+      GrapeExample = Module.new
+      GrapeExample.send(:const_set, :Api, app)
+      example.run
+      Object.send(:remove_const, :GrapeExample)
+    end
+
+    describe "#call" do
+      context "when AppSignal is not active" do
+        before(:context) do
+          Appsignal.config = nil
+          Appsignal::Hooks.load_hooks
+        end
+
+        it "creates no transaction" do
+          expect(Appsignal::Transaction).to_not receive(:create)
+        end
+
+        it "calls the endpoint normally" do
+          expect(api_endpoint).to receive(:call).with(env)
+        end
+
+        after { middleware.call(env) }
+      end
+
+      context "when AppSignal is active" do
+        let(:transaction) { http_request_transaction }
+        before :context do
+          Appsignal.config = project_fixture_config
+          expect(Appsignal.active?).to be_truthy
+        end
+        before do
+          expect(Appsignal::Transaction).to receive(:create).with(
+            kind_of(String),
+            Appsignal::Transaction::HTTP_REQUEST,
+            kind_of(::Rack::Request)
+          ).and_return(transaction)
+        end
+
+        context "without error" do
+          it "calls the endpoint" do
+            expect(api_endpoint).to receive(:call).with(env)
+          end
+
+          it "sets metadata" do
+            expect(transaction).to receive(:set_http_or_background_queue_start)
+            expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/ping")
+            expect(transaction).to receive(:set_metadata).with("path", "/ping")
+            expect(transaction).to receive(:set_metadata).with("method", "POST")
+          end
+
+          after { middleware.call(env) }
+        end
+
+        context "with error" do
+          let(:app) do
+            Class.new(::Grape::API) do
+              format :json
+              post :ping do
+                raise ExampleException
+              end
+            end
+          end
+
+          it "sets metadata" do
+            expect(transaction).to receive(:set_http_or_background_queue_start)
+            expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/ping")
+            expect(transaction).to receive(:set_metadata).with("path", "/ping")
+            expect(transaction).to receive(:set_metadata).with("method", "POST")
+          end
+
+          it "sets the error" do
+            expect(transaction).to receive(:set_error).with(kind_of(ExampleException))
+          end
+
+          after do
+            expect { middleware.call(env) }.to raise_error ExampleException
+          end
+        end
+
+        context "with route" do
+          let(:app) do
+            Class.new(::Grape::API) do
+              route [:get, :post], "hello" do
+                "Hello!"
+              end
+            end
+          end
+          let(:env) do
+            http_request_env_with_data \
+              "api.endpoint" => api_endpoint,
+              "REQUEST_METHOD" => "GET",
+              :path => ""
+          end
+
+          it "sets non-unique route path" do
+            expect(transaction).to receive(:set_action).with("GET::GrapeExample::Api#/hello")
+            expect(transaction).to receive(:set_metadata).with("path", "/hello")
+            expect(transaction).to receive(:set_metadata).with("method", "GET")
+          end
+
+          after { middleware.call(env) }
+        end
+
+        context "with route_param" do
+          let(:app) do
+            Class.new(::Grape::API) do
+              format :json
+              resource :users do
+                route_param :id do
+                  get do
+                    { :name => "Tom" }
+                  end
+                end
+              end
+            end
+          end
+          let(:env) do
+            http_request_env_with_data \
+              "api.endpoint" => api_endpoint,
+              "REQUEST_METHOD" => "GET",
+              :path => ""
+          end
+
+          it "sets non-unique route_param path" do
+            expect(transaction).to receive(:set_action_if_nil).with("GET::GrapeExample::Api#/users/:id/")
+            expect(transaction).to receive(:set_metadata).with("path", "/users/:id/")
+            expect(transaction).to receive(:set_metadata).with("method", "GET")
+          end
+
+          after { middleware.call(env) }
+        end
+
+        context "with namespaced path" do
+          context "with symbols" do
+            let(:app) do
+              Class.new(::Grape::API) do
+                format :json
+                namespace :v1 do
+                  namespace :beta do
+                    post :ping do
+                      { :message => "Hello namespaced world!" }
+                    end
+                  end
+                end
+              end
+            end
+
+            it "sets namespaced path" do
+              expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
+              expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
+              expect(transaction).to receive(:set_metadata).with("method", "POST")
+            end
+          end
+
+          context "with strings" do
+            context "without / prefix" do
+              let(:app) do
+                Class.new(::Grape::API) do
+                  format :json
+                  namespace "v1" do
+                    namespace "beta" do
+                      post "ping" do
+                        { :message => "Hello namespaced world!" }
+                      end
+                    end
+                  end
+                end
+              end
+
+              it "sets namespaced path" do
+                expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
+                expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
+                expect(transaction).to receive(:set_metadata).with("method", "POST")
+              end
+            end
+
+            context "with / prefix" do
+              let(:app) do
+                Class.new(::Grape::API) do
+                  format :json
+                  namespace "/v1" do
+                    namespace "/beta" do
+                      post "/ping" do
+                        { :message => "Hello namespaced world!" }
+                      end
+                    end
+                  end
+                end
+              end
+
+              it "sets namespaced path" do
+                expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
+                expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
+                expect(transaction).to receive(:set_metadata).with("method", "POST")
+              end
+            end
+          end
+
+          after { middleware.call(env) }
+        end
+      end
+    end
+  end
+end