appsignal 2.5.0.alpha.1-java

data/spec/lib/appsignal/demo_spec.rb

@@ -0,0 +1,87 @@
+require "appsignal/demo"
+
+describe Appsignal::Demo do
+  before do
+    # Ignore sleeps to speed up the test
+    allow(described_class).to receive(:sleep)
+  end
+
+  describe ".transmit" do
+    subject { described_class.transmit }
+
+    context "without config" do
+      it "returns false" do
+        expect(silence { subject }).to eq(false)
+      end
+    end
+
+    context "with config" do
+      let(:config) { project_fixture_config("production") }
+      before { Appsignal.config = config }
+
+      it "returns true" do
+        expect(subject).to eq(true)
+      end
+
+      it "creates demonstration samples" do
+        expect(described_class).to receive(:create_example_error_request)
+        expect(described_class).to receive(:create_example_performance_request)
+        subject
+      end
+    end
+  end
+
+  describe ".create_example_error_request" do
+    let!(:error_transaction) { http_request_transaction }
+    let(:config) { project_fixture_config("production") }
+    before do
+      Appsignal.config = config
+      expect(Appsignal::Transaction).to receive(:new).with(
+        kind_of(String),
+        Appsignal::Transaction::HTTP_REQUEST,
+        kind_of(::Rack::Request),
+        kind_of(Hash)
+      ).and_return(error_transaction)
+    end
+    subject { described_class.send(:create_example_error_request) }
+
+    it "sets an error" do
+      expect(error_transaction).to receive(:set_error).with(kind_of(described_class::TestError))
+      expect(error_transaction).to receive(:set_metadata).with("path", "/hello")
+      expect(error_transaction).to receive(:set_metadata).with("method", "GET")
+      expect(error_transaction).to receive(:set_metadata).with("demo_sample", "true")
+      expect(error_transaction).to receive(:complete)
+      subject
+    end
+  end
+
+  describe ".create_example_performance_request" do
+    let!(:performance_transaction) { http_request_transaction }
+    let(:config) { project_fixture_config("production") }
+    before do
+      Appsignal.config = config
+      expect(Appsignal::Transaction).to receive(:new).with(
+        kind_of(String),
+        Appsignal::Transaction::HTTP_REQUEST,
+        kind_of(::Rack::Request),
+        kind_of(Hash)
+      ).and_return(performance_transaction)
+    end
+    subject { described_class.send(:create_example_performance_request) }
+
+    it "sends a performance sample" do
+      expect(performance_transaction).to receive(:start_event)
+      expect(performance_transaction).to receive(:finish_event).with(
+        "action_view.render",
+        "Render hello.html.erb",
+        "<h1>Hello world!</h1>",
+        Appsignal::EventFormatter::DEFAULT
+      )
+      expect(performance_transaction).to receive(:set_metadata).with("path", "/hello")
+      expect(performance_transaction).to receive(:set_metadata).with("method", "GET")
+      expect(performance_transaction).to receive(:set_metadata).with("demo_sample", "true")
+      expect(performance_transaction).to receive(:complete)
+      subject
+    end
+  end
+end

data/spec/lib/appsignal/event_formatter/action_view/render_formatter_spec.rb

@@ -0,0 +1,44 @@
+if DependencyHelper.rails_present?
+  require "action_view"
+
+  describe Appsignal::EventFormatter::ActionView::RenderFormatter do
+    before { allow(Rails.root).to receive(:to_s).and_return("/var/www/app/20130101") }
+    let(:klass) { Appsignal::EventFormatter::ActionView::RenderFormatter }
+    let(:formatter) { klass.new }
+
+    it "should register render_partial.action_view and render_template.action_view" do
+      expect(Appsignal::EventFormatter.registered?("render_partial.action_view", klass)).to be_truthy
+      expect(Appsignal::EventFormatter.registered?("render_template.action_view", klass)).to be_truthy
+    end
+
+    describe "#root_path" do
+      subject { formatter.root_path }
+
+      it "returns Rails root path" do
+        is_expected.to eq "/var/www/app/20130101/"
+      end
+    end
+
+    describe "#format" do
+      subject { formatter.format(payload) }
+
+      context "with an identifier" do
+        let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb" } }
+
+        it { is_expected.to eq ["app/views/home/index/html.erb", nil] }
+      end
+
+      context "with a frozen identifier" do
+        let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb".freeze } }
+
+        it { is_expected.to eq ["app/views/home/index/html.erb", nil] }
+      end
+
+      context "without an identifier" do
+        let(:payload) { {} }
+
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+end

data/spec/lib/appsignal/event_formatter/active_record/instantiation_formatter_spec.rb

@@ -0,0 +1,21 @@
+describe Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter do
+  let(:klass)     { Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register instantiation.active_record" do
+    expect(Appsignal::EventFormatter.registered?("instantiation.active_record", klass)).to be_truthy
+  end
+
+  describe "#format" do
+    let(:payload) do
+      {
+        :record_count => 1,
+        :class_name => "User"
+      }
+    end
+
+    subject { formatter.format(payload) }
+
+    it { is_expected.to eq ["User", nil] }
+  end
+end

data/spec/lib/appsignal/event_formatter/active_record/sql_formatter_spec.rb

@@ -0,0 +1,21 @@
+describe Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter do
+  let(:klass)     { Appsignal::EventFormatter::ActiveRecord::SqlFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register sql.active_record" do
+    expect(Appsignal::EventFormatter.registered?("sql.active_record", klass)).to be_truthy
+  end
+
+  describe "#format" do
+    let(:payload) do
+      {
+        :name => "User load",
+        :sql => "SELECT * FROM users"
+      }
+    end
+
+    subject { formatter.format(payload) }
+
+    it { is_expected.to eq ["User load", "SELECT * FROM users", 1] }
+  end
+end

data/spec/lib/appsignal/event_formatter/elastic_search/search_formatter_spec.rb

@@ -0,0 +1,52 @@
+describe Appsignal::EventFormatter::ElasticSearch::SearchFormatter do
+  let(:klass)     { Appsignal::EventFormatter::ElasticSearch::SearchFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register query.moped" do
+    expect(
+      Appsignal::EventFormatter.registered?("search.elasticsearch", klass)
+    ).to be_truthy
+  end
+
+  describe "#format" do
+    let(:payload) do
+      {
+        :name   => "Search",
+        :klass  => "User",
+        :search => { :index => "users", :type => "user", :q => "John Doe" }
+      }
+    end
+
+    it "should return a payload with name and sanitized body" do
+      expect(formatter.format(payload)).to eql([
+        "Search: User",
+        "{:index=>\"users\", :type=>\"user\", :q=>\"?\"}"
+      ])
+    end
+  end
+
+  describe "#sanitized_search" do
+    let(:search) do
+      {
+        :index => "users",
+        :type  => "user",
+        :q     => "John Doe",
+        :other => "Other"
+      }
+    end
+
+    it "should sanitize non-whitelisted params" do
+      expect(
+        formatter.sanitized_search(search)
+      ).to eql(:index => "users", :type => "user", :q => "?", :other => "?")
+    end
+
+    it "should return nil string when search is nil" do
+      expect(formatter.sanitized_search(nil)).to be_nil
+    end
+
+    it "should return nil string when search is not a hash" do
+      expect(formatter.sanitized_search([])).to be_nil
+    end
+  end
+end

data/spec/lib/appsignal/event_formatter/faraday/request_formatter_spec.rb

@@ -0,0 +1,21 @@
+describe Appsignal::EventFormatter::Faraday::RequestFormatter do
+  let(:klass)     { Appsignal::EventFormatter::Faraday::RequestFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register request.faraday" do
+    expect(Appsignal::EventFormatter.registered?("request.faraday", klass)).to be_truthy
+  end
+
+  describe "#format" do
+    let(:payload) do
+      {
+        :method => :get,
+        :url => URI.parse("http://example.org/hello/world?some=param")
+      }
+    end
+
+    subject { formatter.format(payload) }
+
+    it { is_expected.to eq ["GET http://example.org", "GET http://example.org/hello/world"] }
+  end
+end

data/spec/lib/appsignal/event_formatter/mongo_ruby_driver/query_formatter_spec.rb

@@ -0,0 +1,113 @@
+describe Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter do
+  let(:formatter) { Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter }
+
+  describe ".format" do
+    let(:strategy) { :find }
+    let(:command) do
+      {
+        "find"   => "users",
+        "filter" => { "_id" => 1 }
+      }
+    end
+
+    it "should apply a strategy for each key" do
+      expect(formatter).to receive(:apply_strategy)
+        .with(:sanitize_document, "_id" => 1)
+
+      expect(formatter).to receive(:apply_strategy)
+        .with(:allow, "users")
+
+      formatter.format(strategy, command)
+    end
+
+    context "when strategy is unkown" do
+      let(:strategy) { :bananas }
+
+      it "should return an empty hash" do
+        expect(formatter.format(strategy, command)).to eql({})
+      end
+    end
+
+    context "when command is not a hash " do
+      let(:command) { :bananas }
+
+      it "should return an empty hash" do
+        expect(formatter.format(strategy, command)).to eql({})
+      end
+    end
+  end
+
+  describe ".apply_strategy" do
+    context "when strategy is allow" do
+      let(:strategy) { :allow }
+      let(:value)    { { "_id" => 1 } }
+
+      it "should return the given value" do
+        expect(formatter.apply_strategy(strategy, value)).to eql(value)
+      end
+    end
+
+    context "when strategy is deny" do
+      let(:strategy) { :deny }
+      let(:value)    { { "_id" => 1 } }
+
+      it "should return a '?'" do
+        expect(formatter.apply_strategy(strategy, value)).to eql("?")
+      end
+    end
+
+    context "when strategy is deny_array" do
+      let(:strategy) { :deny_array }
+      let(:value)    { { "_id" => 1 } }
+
+      it "should return a sanitized array string" do
+        expect(formatter.apply_strategy(strategy, value)).to eql("[?]")
+      end
+    end
+
+    context "when strategy is sanitize_document" do
+      let(:strategy) { :sanitize_document }
+      let(:value)    { { "_id" => 1 } }
+
+      it "should return a sanitized document" do
+        expect(formatter.apply_strategy(strategy, value)).to eql("_id" => "?")
+      end
+    end
+
+    context "when strategy is sanitize_bulk" do
+      let(:strategy) { :sanitize_bulk }
+      let(:value)    { [{ "q" => { "_id" => 1 }, "u" => [{ "foo" => "bar" }] }] }
+
+      it "should return an array of sanitized bulk documents" do
+        expect(formatter.apply_strategy(strategy, value)).to eql([
+          { "q" => { "_id" => "?" }, "u" => "[?]" }
+        ])
+      end
+
+      context "when bulk has more than one update" do
+        let(:value) do
+          [
+            { "q" => { "_id" => 1 }, "u" => [{ "foo" => "bar" }] },
+            { "q" => { "_id" => 2 }, "u" => [{ "foo" => "baz" }] }
+          ]
+        end
+
+        it "should return only the first value of sanitized bulk documents" do
+          expect(formatter.apply_strategy(strategy, value)).to eql([
+            { "q" => { "_id" => "?" }, "u" => "[?]" },
+            "[...]"
+          ])
+        end
+      end
+    end
+
+    context "when strategy is missing" do
+      let(:strategy) { nil }
+      let(:value)    { { "_id" => 1 } }
+
+      it "should return a '?'" do
+        expect(formatter.apply_strategy(strategy, value)).to eql("?")
+      end
+    end
+  end
+end

data/spec/lib/appsignal/event_formatter/moped/query_formatter_spec.rb

@@ -0,0 +1,112 @@
+describe Appsignal::EventFormatter::Moped::QueryFormatter do
+  let(:klass) { Appsignal::EventFormatter::Moped::QueryFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register query.moped" do
+    expect(Appsignal::EventFormatter.registered?("query.moped", klass)).to be_truthy
+  end
+
+  describe "#format" do
+    let(:payload) { { :ops => [op] } }
+    subject { formatter.format(payload) }
+
+    context "without ops in the payload" do
+      let(:payload) { {} }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "Moped::Protocol::Command" do
+      let(:op) do
+        double(
+          :full_collection_name => "database.collection",
+          :selector             => { "query" => { "_id" => "abc" } },
+          :class                => double(:to_s => "Moped::Protocol::Command")
+        )
+      end
+
+      it { is_expected.to eq ["Command", '{:database=>"database.collection", :selector=>{"query"=>"?"}}'] }
+    end
+
+    context "Moped::Protocol::Query" do
+      let(:op) do
+        double(
+          :full_collection_name => "database.collection",
+          :selector             => { "_id" => "abc" },
+          :flags                => [],
+          :limit                => 0,
+          :skip                 => 0,
+          :fields               => nil,
+          :class                => double(:to_s => "Moped::Protocol::Query")
+        )
+      end
+
+      it { is_expected.to eq ["Query", '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :flags=>[], :limit=>0, :skip=>0, :fields=>nil}'] }
+    end
+
+    context "Moped::Protocol::Delete" do
+      let(:op) do
+        double(
+          :full_collection_name => "database.collection",
+          :selector             => { "_id" => "abc" },
+          :flags                => [],
+          :class                => double(:to_s => "Moped::Protocol::Delete")
+        )
+      end
+
+      it { is_expected.to eq ["Delete", '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :flags=>[]}'] }
+    end
+
+    context "Moped::Protocol::Insert" do
+      let(:op) do
+        double(
+          :full_collection_name => "database.collection",
+          :flags                => [],
+          :documents            => [
+            { "_id" => "abc", "events" => { "foo" => [{ "bar" => "baz" }] } },
+            { "_id" => "def", "events" => { "foo" => [{ "baz" => "bar" }] } }
+          ],
+          :class                => double(:to_s => "Moped::Protocol::Insert")
+        )
+      end
+
+      it { is_expected.to eq ["Insert", '{:database=>"database.collection", :documents=>{"_id"=>"?", "events"=>"?"}, :count=>2, :flags=>[]}'] }
+    end
+
+    context "Moped::Protocol::Update" do
+      let(:op) do
+        double(
+          :full_collection_name => "database.collection",
+          :selector             => { "_id" => "abc" },
+          :update               => { "user.name" => "James Bond" },
+          :flags                => [],
+          :class                => double(:to_s => "Moped::Protocol::Update")
+        )
+      end
+
+      it { is_expected.to eq ["Update", '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :update=>{"user.?"=>"?"}, :flags=>[]}'] }
+    end
+
+    context "Moped::Protocol::KillCursors" do
+      let(:op) do
+        double(
+          :number_of_cursor_ids => 2,
+          :class                => double(:to_s => "Moped::Protocol::KillCursors")
+        )
+      end
+
+      it { is_expected.to eq ["KillCursors", "{:number_of_cursor_ids=>2}"] }
+    end
+
+    context "Moped::Protocol::Other" do
+      let(:op) do
+        double(
+          :full_collection_name => "database.collection",
+          :class                => double(:to_s => "Moped::Protocol::Other")
+        )
+      end
+
+      it { is_expected.to eq ["Other", '{:database=>"database.collection"}'] }
+    end
+  end
+end