appsignal 3.0.1-java → 3.0.5-java

data/gemfiles/resque-2.gemfile

@@ -4,7 +4,3 @@ gem 'resque', "~> 2.0"
 gem 'sinatra'
 
 gemspec :path => '../'
-
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.1.0")
-  gem 'nokogiri', '~> 1.6.0'
-end

data/gemfiles/sequel-435.gemfile

@@ -6,6 +6,5 @@ if RUBY_PLATFORM == "java"
 else
   gem 'sqlite3'
 end
-gem 'rack', '~> 1.6'
 
 gemspec :path => '../'

data/gemfiles/sequel.gemfile

@@ -6,6 +6,5 @@ if RUBY_PLATFORM == "java"
 else
   gem 'sqlite3'
 end
-gem 'rack', '~> 1.6'
 
 gemspec :path => '../'

data/gemfiles/sinatra.gemfile

@@ -1,6 +1,5 @@
 source 'https://rubygems.org'
 
 gem 'sinatra'
-gem 'rack', '~> 1.6'
 
 gemspec :path => '../'

data/lib/appsignal/extension.rb

@@ -40,6 +40,16 @@ module Appsignal
       def method_missing(m, *args, &block)
         super if Appsignal.testing?
       end
+
+      unless Appsignal.extension_loaded?
+        def data_map_new
+          Appsignal::Extension::MockData.new
+        end
+
+        def data_array_new
+          Appsignal::Extension::MockData.new
+        end
+      end
     end
 
     if Appsignal::System.jruby?
@@ -62,5 +72,45 @@ module Appsignal
         "#<#{self.class.name}:#{object_id} #{self}>"
       end
     end
+
+    # Mock of the {Data} class. This mock is used when the extension cannot be
+    # loaded. This mock listens to all method calls and does nothing, and
+    # prevents NoMethodErrors from being raised.
+    #
+    # Disabled in testing so we can make sure that we don't miss an extension
+    # function implementation.
+    #
+    # This class inherits from the {Data} class so that it passes type checks.
+    class MockData < Data
+      def initialize(*_args)
+        # JRuby extension requirement, as it sends a pointer to the Data object
+        # when creating it
+      end
+
+      def method_missing(_method, *_args, &_block)
+        super if Appsignal.testing?
+      end
+
+      def to_s
+        "{}"
+      end
+    end
+
+    # Mock of the {Transaction} class. This mock is used when the extension
+    # cannot be loaded. This mock listens to all method calls and does nothing,
+    # and prevents NoMethodErrors from being raised.
+    #
+    # Disabled in testing so we can make sure that we don't miss an extension
+    # function implementation.
+    class MockTransaction
+      def initialize(*_args)
+        # JRuby extension requirement, as it sends a pointer to the Transaction
+        # object when creating it
+      end
+
+      def method_missing(_method, *_args, &_block)
+        super if Appsignal.testing?
+      end
+    end
   end
 end

data/lib/appsignal/helpers/instrumentation.rb

@@ -223,7 +223,7 @@ module Appsignal
             "The namespace argument for `Appsignal.send_error` is deprecated. " \
             "Please use the block method to set the namespace instead.\n\n" \
             "  Appsignal.send_error(error) do |transaction|\n" \
-            "    transaction.namespace(#{namespace.inspect})\n" \
+            "    transaction.set_namespace(#{namespace.inspect})\n" \
             "  end\n\n" \
             "Appsignal.send_error called on location: #{call_location}"
         end
@@ -316,7 +316,7 @@ module Appsignal
             "The namespace argument for `Appsignal.set_error` is deprecated. " \
             "Please use the block method to set the namespace instead.\n\n" \
             "  Appsignal.set_error(error) do |transaction|\n" \
-            "    transaction.namespace(#{namespace.inspect})\n" \
+            "    transaction.set_namespace(#{namespace.inspect})\n" \
             "  end\n\n" \
             "Appsignal.set_error called on location: #{call_location}"
         end

data/lib/appsignal/hooks.rb

@@ -32,7 +32,7 @@ module Appsignal
         return unless dependencies_present?
         return if installed?
 
-        Appsignal.logger.info("Installing #{name} hook")
+        Appsignal.logger.debug("Installing #{name} hook")
         begin
           install
           @installed = true

data/lib/appsignal/integrations/padrino.rb

@@ -7,7 +7,7 @@ module Appsignal
     # @api private
     module PadrinoPlugin
       def self.init
-        Appsignal.logger.info("Loading Padrino (#{Padrino::VERSION}) integration")
+        Appsignal.logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
 
         root = Padrino.mounted_root
         Appsignal.config = Appsignal::Config.new(root, Padrino.env)

data/lib/appsignal/integrations/railtie.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Appsignal.logger.info("Loading Rails (#{Rails.version}) integration")
+Appsignal.logger.debug("Loading Rails (#{Rails.version}) integration")
 
 require "appsignal/utils/rails_helper"
 require "appsignal/rack/rails_instrumentation"
@@ -30,10 +30,6 @@ module Appsignal
           Appsignal::Rack::RailsInstrumentation
         )
 
-        if Appsignal.config[:enable_frontend_error_catching]
-          app.middleware.insert_before(Appsignal::Rack::RailsInstrumentation)
-        end
-
         Appsignal.start
       end
     end

data/lib/appsignal/integrations/sinatra.rb

@@ -3,7 +3,7 @@
 require "appsignal"
 require "appsignal/rack/sinatra_instrumentation"
 
-Appsignal.logger.info("Loading Sinatra (#{Sinatra::VERSION}) integration")
+Appsignal.logger.debug("Loading Sinatra (#{Sinatra::VERSION}) integration")
 
 app_settings = ::Sinatra::Application.settings
 Appsignal.config = Appsignal::Config.new(

data/lib/appsignal/transaction.rb

@@ -90,7 +90,7 @@ module Appsignal
         @transaction_id,
         @namespace,
         self.class.garbage_collection_profiler.total_time
-      )
+      ) || Appsignal::Extension::MockTransaction.new
     end
 
     def nil_transaction?
@@ -228,7 +228,7 @@ module Appsignal
     # "Web" and "background_job" gets transformed to "Background".
     #
     # @example
-    #   transaction.set_action("admin")
+    #   transaction.set_namespace("background")
     #
     # @param namespace [String] namespace name to use for this transaction.
     # @return [void]

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.0.1".freeze
+  VERSION = "3.0.5".freeze
 end

data/mono.yml

@@ -0,0 +1,16 @@
+---
+language: ruby
+repo: "https://github.com/appsignal/appsignal-ruby"
+bootstrap:
+  post:
+    - "rake extension:install"
+clean:
+  post:
+    - "bundle exec rake extension:clean"
+    - "rm -rf pkg"
+build:
+  command: "bundle exec rake build:all"
+publish:
+  gem_files_dir: pkg/
+test:
+  command: "bundle exec rake test"

data/spec/lib/appsignal/cli/diagnose_spec.rb

@@ -115,6 +115,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
     it "logs to the log file" do
       run
       log_contents = File.read(config.log_file_path)
+      p log_contents
       expect(log_contents).to contains_log :info, "Starting AppSignal diagnose"
     end
 

data/spec/lib/appsignal/extension_install_failure_spec.rb

@@ -1,13 +1,6 @@
 describe Appsignal::Extension, :extension_installation_failure do
   context "when the extension library cannot be loaded" do
-    # This test breaks the installation on purpose and is not run by default.
-    # See `rake test:failure`. If this test was run, run `rake
-    # extension:install` again to fix the extension installation.
     it "prints and logs an error" do
-      # ENV var to make sure installation fails on purpurse
-      ENV["_TEST_APPSIGNAL_EXTENSION_FAILURE"] = "true"
-      `rake extension:install` # Run installation
-
       require "open3"
       _stdout, stderr, _status = Open3.capture3("bin/appsignal --version")
       expect(stderr).to include("ERROR: AppSignal failed to load extension")

data/spec/lib/appsignal/extension_spec.rb

@@ -119,22 +119,56 @@ describe Appsignal::Extension do
     end
   end
 
-  context "when the extension library cannot be loaded" do
-    subject { Appsignal::Extension }
+  context "when the extension library cannot be loaded", :extension_installation_failure do
+    let(:ext) { Appsignal::Extension }
 
-    before do
-      allow(Appsignal).to receive(:extension_loaded).and_return(false)
-      allow(Appsignal).to receive(:testing?).and_return(false)
+    around do |example|
+      Appsignal::Testing.without_testing { example.run }
     end
 
     it "should indicate that the extension is not loaded" do
       expect(Appsignal.extension_loaded?).to be_falsy
     end
 
-    it "should not raise errors when methods are called" do
-      expect do
-        subject.something
-      end.not_to raise_error
+    it "does not raise errors when methods are called" do
+      ext.appsignal_start
+      ext.something
+    end
+
+    describe Appsignal::Extension::MockData do
+      it "does not error on missing data_map_new extension method calls" do
+        map = ext.data_map_new
+        expect(map).to be_kind_of(Appsignal::Extension::MockData)
+        # Does not raise errors any arbitrary method call that does not exist
+        map.set_string("key", "value")
+        map.set_int("key", 123)
+        map.something
+      end
+
+      it "does not error on missing data_array_new extension method calls" do
+        array = ext.data_array_new
+        expect(array).to be_kind_of(Appsignal::Extension::MockData)
+        # Does not raise errors any arbitrary method call that does not exist
+        array.append_string("value")
+        array.append_int(123)
+        array.something
+      end
+    end
+
+    describe Appsignal::Extension::MockTransaction do
+      it "does not error on missing transaction extension method calls" do
+        transaction = described_class.new
+
+        transaction.start_event(0)
+        transaction.finish_event(
+          "name",
+          "title",
+          "body",
+          Appsignal::EventFormatter::DEFAULT,
+          0
+        )
+        transaction.something
+      end
     end
   end
 end

data/spec/lib/appsignal/hooks_spec.rb

@@ -68,7 +68,10 @@ describe Appsignal::Hooks do
     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
-    expect(Appsignal.logger).to receive(:debug).once do |message|
+    expect(Appsignal.logger).to receive(:debug).ordered do |message|
+      expect(message).to eq("Installing mock_error_hook hook")
+    end
+    expect(Appsignal.logger).to receive(:debug).ordered do |message|
       # Start of the error backtrace as debug log
       expect(message).to start_with(File.expand_path("../../../../", __FILE__))
     end

data/spec/lib/appsignal/transaction_spec.rb

@@ -246,6 +246,23 @@ describe Appsignal::Transaction do
         expect(transaction.ext).to_not be_nil
       end
 
+      context "when extension is not loaded", :extension_installation_failure do
+        around do |example|
+          Appsignal::Testing.without_testing { example.run }
+        end
+
+        it "does not error on missing extension method calls" do
+          expect(transaction.ext).to be_kind_of(Appsignal::Extension::MockTransaction)
+          transaction.start_event
+          transaction.finish_event(
+            "name",
+            "title",
+            "body",
+            Appsignal::EventFormatter::DEFAULT
+          )
+        end
+      end
+
       it "sets the transaction id" do
         expect(transaction.transaction_id).to eq "1"
       end

data/spec/lib/appsignal/utils/data_spec.rb

@@ -4,110 +4,156 @@ describe Appsignal::Utils::Data do
   describe ".generate" do
     subject { Appsignal::Utils::Data.generate(body) }
 
-    context "with a valid hash body" do
-      let(:body) do
-        {
-          "the" => "payload",
-          "int" => 1, # Fixnum
-          "int61" => 1 << 61, # Fixnum
-          "int62" => 1 << 62, # Bignum, this one still works
-          "int63" => 1 << 63, # Bignum, turnover point for C, too big for long
-          "int64" => 1 << 64, # Bignum
-          "float" => 1.0,
-          1 => true,
-          nil => "test",
-          :foo => [1, 2, "three", { "foo" => "bar" }],
-          "bar" => nil,
-          "baz" => { "foo" => "bʊr", "arr" => [1, 2] }
-        }
+    context "when extension is not loaded", :extension_installation_failure do
+      around do |example|
+        Appsignal::Testing.without_testing { example.run }
       end
 
-      it { is_expected.to eq Appsignal::Utils::Data.generate(body) }
-      it { is_expected.to_not eq Appsignal::Utils::Data.generate({}) }
-
-      describe "#to_s" do
-        it "returns a serialized hash" do
-          expect(subject.to_s).to eq %({"":"test",) +
-            %("1":true,) +
-            %("bar":null,) +
-            %("baz":{"arr":[1,2],"foo":"bʊr"},) +
-            %("float":1.0,) +
-            %("foo":[1,2,"three",{"foo":"bar"}],) +
-            %("int":1,) +
-            %("int61":#{1 << 61},) +
-            %("int62":#{1 << 62},) +
-            %("int63":"bigint:#{1 << 63}",) +
-            %("int64":"bigint:#{1 << 64}",) +
-            %("the":"payload"})
+      context "with valid hash body" do
+        let(:body) { hash_body }
+
+        it "does not error and returns MockData class" do
+          expect(subject).to be_kind_of(Appsignal::Extension::MockData)
+          expect(subject.to_s).to eql("{}")
         end
       end
-    end
 
-    context "with a valid array body" do
-      let(:body) do
-        [
-          nil,
-          true,
-          false,
-          "string",
-          1, # Fixnum
-          1.0, # Float
-          1 << 61, # Fixnum
-          1 << 62, # Bignum, this one still works
-          1 << 63, # Bignum, turnover point for C, too big for long
-          1 << 64, # Bignum
-          { "arr" => [1, 2, "three"], "foo" => "bʊr" }
-        ]
+      context "with valid array body" do
+        let(:body) { array_body }
+
+        it "does not error and returns MockData class" do
+          expect(subject).to be_kind_of(Appsignal::Extension::MockData)
+          expect(subject.to_s).to eql("{}")
+        end
       end
 
-      it { is_expected.to eq Appsignal::Utils::Data.generate(body) }
-      it { is_expected.to_not eq Appsignal::Utils::Data.generate({}) }
-
-      describe "#to_s" do
-        it "returns a serialized array" do
-          expect(subject.to_s).to eq %([null,) +
-            %(true,) +
-            %(false,) +
-            %(\"string\",) +
-            %(1,) +
-            %(1.0,) +
-            %(#{1 << 61},) +
-            %(#{1 << 62},) +
-            %("bigint:#{1 << 63}",) +
-            %("bigint:#{1 << 64}",) +
-            %({\"arr\":[1,2,\"three\"],\"foo\":\"bʊr\"}])
+      context "with an invalid body" do
+        let(:body) { "body" }
+
+        it "raise a type error" do
+          expect do
+            subject
+          end.to raise_error TypeError
         end
       end
     end
 
-    context "with a body that contains strings with invalid utf-8 content" do
-      let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack("c*") }
-      let(:body) do
-        {
-          "field_one" => [0x61, 0x61].pack("c*"),
-          :field_two => string_with_invalid_utf8,
-          "field_three" => [
-            "one", string_with_invalid_utf8
-          ],
-          "field_four" => {
-            "one" => string_with_invalid_utf8
-          }
-        }
+    context "when extension is loaded" do
+      context "with a valid hash body" do
+        let(:body) { hash_body }
+
+        it "returns a valid Data object" do
+          is_expected.to eq Appsignal::Utils::Data.generate(body)
+          is_expected.to_not eq Appsignal::Utils::Data.generate({})
+        end
+
+        describe "#to_s" do
+          it "returns a serialized hash" do
+            expect(subject.to_s).to eq %({"":"test",) +
+              %("1":true,) +
+              %("bar":null,) +
+              %("baz":{"arr":[1,2],"foo":"bʊr"},) +
+              %("float":1.0,) +
+              %("foo":[1,2,"three",{"foo":"bar"}],) +
+              %("int":1,) +
+              %("int61":#{1 << 61},) +
+              %("int62":#{1 << 62},) +
+              %("int63":"bigint:#{1 << 63}",) +
+              %("int64":"bigint:#{1 << 64}",) +
+              %("the":"payload"})
+          end
+        end
+      end
+
+      context "with a valid array body" do
+        let(:body) { array_body }
+
+        it "returns a valid Data object" do
+          is_expected.to eq Appsignal::Utils::Data.generate(body)
+          is_expected.to_not eq Appsignal::Utils::Data.generate({})
+        end
+
+        describe "#to_s" do
+          it "returns a serialized array" do
+            expect(subject.to_s).to eq %([null,) +
+              %(true,) +
+              %(false,) +
+              %(\"string\",) +
+              %(1,) +
+              %(1.0,) +
+              %(#{1 << 61},) +
+              %(#{1 << 62},) +
+              %("bigint:#{1 << 63}",) +
+              %("bigint:#{1 << 64}",) +
+              %({\"arr\":[1,2,\"three\"],\"foo\":\"bʊr\"}])
+          end
+        end
       end
 
-      describe "#to_s" do
-        it { expect(subject.to_s).to eq %({"field_four":{"one":"aa�"},"field_one":"aa","field_three":["one","aa�"],"field_two":"aa�"}) }
+      context "with a body that contains strings with invalid utf-8 content" do
+        let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack("c*") }
+        let(:body) do
+          {
+            "field_one" => [0x61, 0x61].pack("c*"),
+            :field_two => string_with_invalid_utf8,
+            "field_three" => [
+              "one", string_with_invalid_utf8
+            ],
+            "field_four" => {
+              "one" => string_with_invalid_utf8
+            }
+          }
+        end
+
+        describe "#to_s" do
+          it "returns a JSON representation in a String" do
+            expect(subject.to_s).to eq %({"field_four":{"one":"aa�"},"field_one":"aa","field_three":["one","aa�"],"field_two":"aa�"})
+          end
+        end
       end
-    end
 
-    context "with an invalid body" do
-      let(:body) { "body" }
+      context "with an invalid body" do
+        let(:body) { "body" }
 
-      it "should raise a type error" do
-        expect do
-          subject
-        end.to raise_error TypeError
+        it "raises a type error" do
+          expect do
+            subject
+          end.to raise_error TypeError
+        end
       end
     end
   end
+
+  def hash_body
+    {
+      "the" => "payload",
+      "int" => 1, # Fixnum
+      "int61" => 1 << 61, # Fixnum
+      "int62" => 1 << 62, # Bignum, this one still works
+      "int63" => 1 << 63, # Bignum, turnover point for C, too big for long
+      "int64" => 1 << 64, # Bignum
+      "float" => 1.0,
+      1 => true,
+      nil => "test",
+      :foo => [1, 2, "three", { "foo" => "bar" }],
+      "bar" => nil,
+      "baz" => { "foo" => "bʊr", "arr" => [1, 2] }
+    }
+  end
+
+  def array_body
+    [
+      nil,
+      true,
+      false,
+      "string",
+      1, # Fixnum
+      1.0, # Float
+      1 << 61, # Fixnum
+      1 << 62, # Bignum, this one still works
+      1 << 63, # Bignum, turnover point for C, too big for long
+      1 << 64, # Bignum
+      { "arr" => [1, 2, "three"], "foo" => "bʊr" }
+    ]
+  end
 end