appsignal 2.5.0.alpha.1-java

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

@@ -0,0 +1,44 @@
+describe Appsignal::Hooks::MongoRubyDriverHook do
+  require "appsignal/integrations/mongo_ruby_driver"
+
+  context "with mongo ruby driver" do
+    let(:subscriber) { Appsignal::Hooks::MongoMonitorSubscriber.new }
+    before { allow(Appsignal::Hooks::MongoMonitorSubscriber).to receive(:new).and_return(subscriber) }
+
+    before(:context) do
+      module Mongo
+        module Monitoring
+          COMMAND = "command".freeze
+
+          class Global
+            def subscribe
+            end
+          end
+        end
+      end
+    end
+    after(:context) { Object.send(:remove_const, :Mongo) }
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    it "adds a subscriber to Mongo::Monitoring" do
+      expect(Mongo::Monitoring::Global).to receive(:subscribe)
+        .with("command", subscriber)
+        .at_least(:once)
+
+      Appsignal::Hooks::MongoRubyDriverHook.new.install
+    end
+  end
+
+  context "without mongo ruby driver" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+describe Appsignal::Hooks::NetHttpHook do
+  before :context do
+    start_agent
+  end
+
+  context "with Net::HTTP instrumentation enabled" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    it "should instrument a http request" do
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+      expect(Appsignal::Transaction.current).to receive(:start_event)
+        .at_least(:once)
+      expect(Appsignal::Transaction.current).to receive(:finish_event)
+        .at_least(:once)
+        .with("request.net_http", "GET http://www.google.com", nil, 0)
+
+      stub_request(:any, "http://www.google.com/")
+
+      Net::HTTP.get_response(URI.parse("http://www.google.com"))
+    end
+
+    it "should instrument a https request" do
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+      expect(Appsignal::Transaction.current).to receive(:start_event)
+        .at_least(:once)
+      expect(Appsignal::Transaction.current).to receive(:finish_event)
+        .at_least(:once)
+        .with("request.net_http", "GET https://www.google.com", nil, 0)
+
+      stub_request(:any, "https://www.google.com/")
+
+      uri = URI.parse("https://www.google.com")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.get(uri.request_uri)
+    end
+  end
+
+  context "with Net::HTTP instrumentation disabled" do
+    before { Appsignal.config.config_hash[:instrument_net_http] = false }
+    after { Appsignal.config.config_hash[:instrument_net_http] = true }
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+describe Appsignal::Hooks::PassengerHook do
+  context "with passenger" do
+    before(:context) do
+      module PhusionPassenger
+      end
+    end
+    after(:context) { Object.send(:remove_const, :PhusionPassenger) }
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    it "adds behavior to stopping_worker_process and starting_worker_process" do
+      expect(PhusionPassenger).to receive(:on_event).with(:starting_worker_process)
+      expect(PhusionPassenger).to receive(:on_event).with(:stopping_worker_process)
+
+      Appsignal::Hooks::PassengerHook.new.install
+    end
+  end
+
+  context "without passenger" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+describe Appsignal::Hooks::PumaHook do
+  context "with puma" do
+    before(:context) do
+      class Puma
+        def self.cli_config
+          @cli_config ||= CliConfig.new
+        end
+
+        class Cluster
+          def stop_workers
+          end
+        end
+      end
+
+      class CliConfig
+        attr_accessor :options
+
+        def initialize
+          @options = {}
+        end
+      end
+    end
+    after(:context) { Object.send(:remove_const, :Puma) }
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when installed" do
+      before do
+        Appsignal::Hooks::PumaHook.new.install
+      end
+
+      it "adds behavior to Unicorn::Worker#close" do
+        cluster = Puma::Cluster.new
+
+        expect(Appsignal).to receive(:stop)
+        expect(cluster).to receive(:stop_workers_without_appsignal)
+
+        cluster.stop_workers
+      end
+    end
+
+    context "with nil hooks" do
+      before do
+        Puma.cli_config.options.delete(:before_worker_boot)
+        Puma.cli_config.options.delete(:before_worker_shutdown)
+        Appsignal::Hooks::PumaHook.new.install
+      end
+
+      it "should add a before shutdown worker callback" do
+        expect(Puma.cli_config.options[:before_worker_boot].first).to be_a(Proc)
+        expect(Puma.cli_config.options[:before_worker_shutdown].first).to be_a(Proc)
+      end
+    end
+
+    context "with existing hooks" do
+      before do
+        Puma.cli_config.options[:before_worker_boot] = []
+        Puma.cli_config.options[:before_worker_shutdown] = []
+        Appsignal::Hooks::PumaHook.new.install
+      end
+
+      it "should add a before shutdown worker callback" do
+        expect(Puma.cli_config.options[:before_worker_boot].first).to be_a(Proc)
+        expect(Puma.cli_config.options[:before_worker_shutdown].first).to be_a(Proc)
+      end
+    end
+  end
+
+  context "without puma" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+describe Appsignal::Hooks::QueHook do
+  if DependencyHelper.que_present?
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    it "installs the QuePlugin" do
+      expect(Que::Job.included_modules).to include(Appsignal::Integrations::QuePlugin)
+    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/rake_spec.rb

@@ -0,0 +1,73 @@
+require "rake"
+
+describe Appsignal::Hooks::RakeHook do
+  let(:task) { Rake::Task.new("task:name", Rake::Application.new) }
+  let(:arguments) { Rake::TaskArguments.new(["foo"], ["bar"]) }
+  let(:generic_request) { Appsignal::Transaction::GenericRequest.new({}) }
+  before(:context) do
+    Appsignal.config = project_fixture_config
+    expect(Appsignal.active?).to be_truthy
+    Appsignal::Hooks.load_hooks
+  end
+
+  describe "#execute" do
+    context "without error" do
+      it "creates no transaction" do
+        expect(Appsignal::Transaction).to_not receive(:create)
+      end
+
+      it "calls the original task" do
+        expect(task).to receive(:execute_without_appsignal).with("foo")
+      end
+
+      after { task.execute("foo") }
+    end
+
+    context "with error" do
+      let(:error) { ExampleException }
+      let(:transaction) { background_job_transaction }
+      before do
+        task.enhance { raise error }
+
+        expect(Appsignal::Transaction).to receive(:create).with(
+          kind_of(String),
+          Appsignal::Transaction::BACKGROUND_JOB,
+          kind_of(Appsignal::Transaction::GenericRequest)
+        ).and_return(transaction)
+      end
+
+      it "sets the action" do
+        expect(transaction).to receive(:set_action).with("task:name")
+      end
+
+      it "sets the error" do
+        expect(transaction).to receive(:set_error).with(error)
+      end
+
+      it "completes the transaction and stops" do
+        expect(transaction).to receive(:complete).ordered
+        expect(Appsignal).to receive(:stop).with("rake").ordered
+      end
+
+      it "adds the task arguments to the request" do
+        expect(Appsignal::Transaction::GenericRequest).to receive(:new)
+          .with(:params => { :foo => "bar" })
+          .and_return(generic_request)
+      end
+
+      context "when first argument is not a `Rake::TaskArguments`" do
+        let(:arguments) { nil }
+
+        it "adds the first argument regardless" do
+          expect(Appsignal::Transaction::GenericRequest).to receive(:new)
+            .with(:params => nil)
+            .and_return(generic_request)
+        end
+      end
+
+      after do
+        expect { task.execute(arguments) }.to raise_error ExampleException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+describe Appsignal::Hooks::RedisHook do
+  before do
+    Appsignal.config = project_fixture_config
+    Appsignal::Hooks.load_hooks
+  end
+
+  if DependencyHelper.redis_present?
+    context "with redis" do
+      context "with instrumentation enabled" do
+        before do
+          Appsignal.config.config_hash[:instrument_redis] = true
+          allow_any_instance_of(Redis::Client).to receive(:process_without_appsignal).and_return(1)
+        end
+
+        describe "#dependencies_present?" do
+          subject { described_class.new.dependencies_present? }
+
+          it { is_expected.to be_truthy }
+        end
+
+        it "should instrument a redis call" do
+          Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+          expect(Appsignal::Transaction.current).to receive(:start_event)
+            .at_least(:once)
+          expect(Appsignal::Transaction.current).to receive(:finish_event)
+            .at_least(:once)
+            .with("query.redis", "redis://127.0.0.1:6379/0", "get ?", 0)
+
+          client = Redis::Client.new
+          expect(client.process([[:get, "key"]])).to eq 1
+        end
+      end
+
+      context "with instrumentation disabled" do
+        before do
+          Appsignal.config.config_hash[:instrument_redis] = false
+        end
+
+        describe "#dependencies_present?" do
+          subject { described_class.new.dependencies_present? }
+
+          it { is_expected.to be_falsy }
+        end
+      end
+    end
+  else
+    context "without redis" do
+      describe "#dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it { is_expected.to be_falsy }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+describe Appsignal::Hooks::SequelHook do
+  if DependencyHelper.sequel_present?
+    let(:db) do
+      if Appsignal::System.jruby?
+        Sequel.connect("jdbc:sqlite::memory:")
+      else
+        Sequel.sqlite
+      end
+    end
+
+    before :context do
+      start_agent
+    end
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "with a transaction" do
+      let(:transaction) { Appsignal::Transaction.current }
+      before do
+        Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+        db.logger = Logger.new($stdout) # To test #log_duration call
+      end
+
+      it "should instrument queries" do
+        expect(transaction).to receive(:start_event).at_least(:once)
+        expect(transaction).to receive(:finish_event)
+          .at_least(:once)
+          .with("sql.sequel", nil, kind_of(String), 1)
+
+        expect(db).to receive(:log_duration).at_least(:once)
+
+        db["SELECT 1"].all.to_a
+      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/shoryuken_spec.rb

@@ -0,0 +1,192 @@
+describe Appsignal::Hooks::ShoryukenMiddleware do
+  let(:current_transaction) { background_job_transaction }
+
+  class DemoShoryukenWorker
+  end
+
+  let(:worker_instance) { DemoShoryukenWorker.new }
+  let(:queue) { double }
+  let(:sqs_msg) { double(:attributes => {}) }
+  let(:body) { {} }
+
+  before do
+    allow(Appsignal::Transaction).to receive(:current).and_return(current_transaction)
+    start_agent
+  end
+
+  context "with a performance call" do
+    let(:queue) { "some-funky-queue-name" }
+    let(:sqs_msg) do
+      double(:attributes => { "SentTimestamp" => Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 })
+    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
+
+      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
+        )
+      end
+
+      context "with parameter filtering" do
+        before do
+          Appsignal.config = project_fixture_config("production")
+          Appsignal.config[:filter_parameters] = ["foo"]
+        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
+          )
+        end
+      end
+    end
+
+    context "with a string as an argument" 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
+        )
+
+        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
+    end
+
+    context "with primitive type as argument" 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
+        )
+
+        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
+    end
+  end
+
+  context "with exception" do
+    let(:transaction) do
+      Appsignal::Transaction.new(
+        SecureRandom.uuid,
+        Appsignal::Transaction::BACKGROUND_JOB,
+        Appsignal::Transaction::GenericRequest.new({})
+      )
+    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)
+    end
+
+    it "sets the exception on the transaction" do
+      expect(transaction).to receive(:set_error).with(ExampleException)
+    end
+
+    after do
+      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)
+    end
+  end
+end
+
+describe Appsignal::Hooks::ShoryukenHook do
+  context "with shoryuken" do
+    before(:context) do
+      module Shoryuken
+        def self.configure_server
+        end
+      end
+      Appsignal::Hooks::ShoryukenHook.new.install
+    end
+
+    after(:context) do
+      Object.send(:remove_const, :Shoryuken)
+    end
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+  end
+
+  context "without shoryuken" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end