appsignal 3.0.13-java → 3.0.17-java

data/lib/appsignal/span.rb

@@ -0,0 +1,92 @@
+module Appsignal
+  class Span
+    def initialize(namespace = nil, ext = nil)
+      @ext = if ext
+               ext
+             else
+               Appsignal::Extension::Span.root(namespace || "")
+             end
+    end
+
+    def child
+      Span.new(nil, @ext.child)
+    end
+
+    def name=(value)
+      @ext.set_name(value)
+    end
+
+    def add_error(error)
+      unless error.is_a?(Exception)
+        Appsignal.logger.error "Appsignal::Span#add_error: Cannot add error. " \
+          "The given value is not an exception: #{error.inspect}"
+        return
+      end
+      return unless error
+
+      backtrace = cleaned_backtrace(error.backtrace)
+      @ext.add_error(
+        error.class.name,
+        error.message.to_s,
+        backtrace ? Appsignal::Utils::Data.generate(backtrace) : Appsignal::Extension.data_array_new
+      )
+    end
+
+    def set_sample_data(key, data)
+      return unless key && data && (data.is_a?(Array) || data.is_a?(Hash))
+      @ext.set_sample_data(
+        key.to_s,
+        Appsignal::Utils::Data.generate(data)
+      )
+    end
+
+    def []=(key, value)
+      case value
+      when String
+        @ext.set_attribute_string(key.to_s, value)
+      when Integer
+        begin
+          @ext.set_attribute_int(key.to_s, value)
+        rescue RangeError
+          @ext.set_attribute_string(key.to_s, "bigint:#{value}")
+        end
+      when TrueClass, FalseClass
+        @ext.set_attribute_bool(key.to_s, value)
+      when Float
+        @ext.set_attribute_double(key.to_s, value)
+      else
+        raise TypeError, "value needs to be a string, int, bool or float"
+      end
+    end
+
+    def to_h
+      json = @ext.to_json
+      return unless json
+      JSON.parse(json)
+    end
+
+    def instrument
+      yield self
+    ensure
+      close
+    end
+
+    def close
+      @ext.close
+    end
+
+    def closed?
+      to_h.nil?
+    end
+
+    private
+
+    def cleaned_backtrace(backtrace)
+      if defined?(::Rails) && backtrace
+        ::Rails.backtrace_cleaner.clean(backtrace, nil)
+      else
+        backtrace
+      end
+    end
+  end
+end

data/lib/appsignal/transaction.rb

@@ -333,7 +333,7 @@ module Appsignal
       backtrace = cleaned_backtrace(error.backtrace)
       @ext.set_error(
         error.class.name,
-        error.message.to_s,
+        cleaned_error_message(error),
         backtrace ? Appsignal::Utils::Data.generate(backtrace) : Appsignal::Extension.data_array_new
       )
     end
@@ -533,6 +533,17 @@ module Appsignal
       end
     end
 
+    # Clean error messages that are known to potentially contain user data.
+    # Returns an unchanged message otherwise.
+    def cleaned_error_message(error)
+      case error.class.to_s
+      when "PG::UniqueViolation"
+        error.message.to_s.gsub(/\)=\(.*\)/, ")=(?)")
+      else
+        error.message.to_s
+      end
+    end
+
     # Stub that is returned by {Transaction.current} if there is no current
     # transaction, so that it's still safe to call methods on it if there is no
     # current transaction.

data/lib/appsignal/version.rb

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

data/lib/appsignal.rb

@@ -116,12 +116,7 @@ module Appsignal
       )
 
       if config.valid?
-        logger.level =
-          if config[:debug]
-            Logger::DEBUG
-          else
-            Logger::INFO
-          end
+        logger.level = config.log_level
         if config.active?
           logger.info "Starting AppSignal #{Appsignal::VERSION} "\
             "(#{$PROGRAM_NAME}, Ruby #{RUBY_VERSION}, #{RUBY_PLATFORM})"
@@ -230,12 +225,11 @@ module Appsignal
       end
 
       logger.level =
-        if config && config[:debug]
-          Logger::DEBUG
+        if config
+          config.log_level
         else
-          Logger::INFO
+          Appsignal::Config::DEFAULT_LOG_LEVEL
         end
-
       logger << @in_memory_log.string if @in_memory_log
     end
 

data/script/{install_lintje → lint_git}

@@ -2,6 +2,8 @@
 
 set -eu
 
+LINTJE_VERSION="0.6.1"
+
 mkdir -p $HOME/bin
 cache_key=v1-lintje-$LINTJE_VERSION
 cache restore $cache_key
@@ -16,3 +18,5 @@ else
     tar -xz --directory $HOME/bin
   cache store $cache_key $HOME/bin/lintje
 fi
+
+$HOME/bin/lintje $SEMAPHORE_GIT_COMMIT_RANGE

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

@@ -115,7 +115,6 @@ 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
 
@@ -192,8 +191,8 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
       it "outputs version numbers" do
         expect(output).to include \
-          "Gem version: #{Appsignal::VERSION}",
-          "Agent version: #{Appsignal::Extension.agent_version}"
+          "Gem version: \"#{Appsignal::VERSION}\"",
+          "Agent version: \"#{Appsignal::Extension.agent_version}\""
       end
 
       it "transmits version numbers in report" do
@@ -295,18 +294,18 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           "Installation result",
           "  Status: success",
           "Language details",
-          "  Implementation: #{jruby ? "jruby" : "ruby"}",
-          "  Ruby version: #{"#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}"}",
+          "  Implementation: \"#{jruby ? "jruby" : "ruby"}\"",
+          "  Ruby version: \"#{"#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}"}\"",
           "Download details",
-          "  Download URL: https://",
-          "  Checksum: verified",
+          "  Download URL: \"https://",
+          "  Checksum: \"verified\"",
           "Build details",
-          "  Install time: 20",
-          "  Architecture: #{Appsignal::System.agent_architecture}",
-          "  Target: #{Appsignal::System.agent_platform}",
+          "  Install time: \"20",
+          "  Architecture: \"#{Appsignal::System.agent_architecture}\"",
+          "  Target: \"#{Appsignal::System.agent_platform}\"",
           "  Musl override: false",
           "  Linux ARM override: false",
-          "  Library type: #{jruby ? "dynamic" : "static"}",
+          "  Library type: \"#{jruby ? "dynamic" : "static"}\"",
           "  Dependencies: {",
           "  Flags: {",
           "Host details",
@@ -611,9 +610,9 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         run
         expect(output).to include \
           "Host information",
-          "Architecture: #{rbconfig["host_cpu"]}",
-          "Operating System: #{rbconfig["host_os"]}",
-          "Ruby version: #{language_version}"
+          "Architecture: \"#{rbconfig["host_cpu"]}\"",
+          "Operating System: \"#{rbconfig["host_os"]}\"",
+          "Ruby version: \"#{language_version}\""
       end
 
       context "when on Microsoft Windows" do
@@ -751,13 +750,13 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         end
 
         it "outputs a warning that no config is loaded" do
-          expect(output).to include "Environment: \"\"\n#{warning_message}"
+          expect(output).to include "environment: \"\"\n#{warning_message}"
           expect(output).to_not have_color_markers
         end
 
         context "with color", :color => true do
           it "outputs a warning that no config is loaded in color" do
-            expect(output).to include "Environment: \"\"\n"
+            expect(output).to include "environment: \"\"\n"
             expect(output).to have_colorized_text :red, warning_message
           end
         end
@@ -786,7 +785,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         describe "environment" do
           it "outputs environment" do
             run
-            expect(output).to include(%(Environment: "production"))
+            expect(output).to include(%(environment: "production"))
           end
 
           context "when the source is a single source" do
@@ -794,7 +793,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
             it "outputs the label source after the value" do
               expect(output).to include(
-                %(Environment: "#{Appsignal.config.env}" (Loaded from: initial)\n)
+                %(environment: "#{Appsignal.config.env}" (Loaded from: initial)\n)
               )
             end
           end
@@ -811,7 +810,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
             it "outputs a list of sources with their values" do
               expect(output).to include(
-                %(  Environment: "production"\n) +
+                %(  environment: "production"\n) +
                 %(    Sources:\n) +
                 %(      initial: "development"\n) +
                 %(      env:     "production"\n)
@@ -905,7 +904,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         before { run_within_dir tmp_dir }
 
         it "outputs environment" do
-          expect(output).to include(%(Environment: "foobar"))
+          expect(output).to include(%(environment: "foobar"))
         end
 
         it "outputs config defaults" do
@@ -1008,7 +1007,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
         it "outputs failure with status code" do
           expect(output).to include "Validation",
-            "Validating Push API key: Failed with status 500\n" +
+            "Validating Push API key: Failed to validate: status 500\n" +
             %("Could not confirm authorization: 500")
         end
 
@@ -1016,14 +1015,19 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           it "outputs error in color" do
             expect(output).to include "Validation",
               "Validating Push API key: " +
-              colorize(%(Failed with status 500\n"Could not confirm authorization: 500"), :red)
+              colorize(
+                "Failed to validate: status 500\n" +
+                %("Could not confirm authorization: 500"),
+                :red
+              )
           end
         end
 
         it "transmits validation in report" do
           expect(received_report).to include(
             "validation" => {
-              "push_api_key" => %(Failed with status 500\n\"Could not confirm authorization: 500")
+              "push_api_key" => "Failed to validate: status 500\n" +
+              %("Could not confirm authorization: 500")
             }
           )
         end

data/spec/lib/appsignal/config_spec.rb

@@ -151,33 +151,34 @@ describe Appsignal::Config do
 
     it "merges with the default config" do
       expect(config.config_hash).to eq(
+        :active                         => true,
+        :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
         :debug                          => false,
-        :log                            => "file",
+        :dns_servers                    => [],
+        :enable_allocation_tracking     => true,
+        :enable_gc_instrumentation      => false,
+        :enable_host_metrics            => true,
+        :enable_minutely_probes         => true,
+        :enable_statsd                  => true,
+        :endpoint                       => "https://push.appsignal.com",
+        :files_world_accessible         => true,
+        :filter_parameters              => [],
+        :filter_session_data            => [],
         :ignore_actions                 => [],
         :ignore_errors                  => [],
         :ignore_namespaces              => [],
-        :filter_parameters              => [],
-        :filter_session_data            => [],
         :instrument_net_http            => true,
         :instrument_redis               => true,
         :instrument_sequel              => true,
-        :skip_session_data              => false,
-        :send_environment_metadata      => true,
-        :send_params                    => true,
-        :endpoint                       => "https://push.appsignal.com",
-        :push_api_key                   => "abc",
+        :log                            => "file",
         :name                           => "TestApp",
-        :active                         => true,
-        :enable_allocation_tracking     => true,
-        :enable_gc_instrumentation      => false,
-        :enable_host_metrics            => true,
-        :enable_minutely_probes         => true,
-        :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
-        :dns_servers                    => [],
-        :files_world_accessible         => true,
-        :transaction_debug_mode         => false,
+        :push_api_key                   => "abc",
+        :request_headers                => [],
         :revision                       => "v2.5.1",
-        :request_headers                => []
+        :send_environment_metadata      => true,
+        :send_params                    => true,
+        :skip_session_data              => false,
+        :transaction_debug_mode         => false
       )
     end
 
@@ -318,13 +319,15 @@ describe Appsignal::Config do
           "non-existing-path",
           "production",
           :running_in_container => true,
-          :debug => true
+          :debug => true,
+          :log_level => "debug"
         )
       end
 
       it "overrides system detected and defaults config" do
         expect(config[:running_in_container]).to be_truthy
         expect(config[:debug]).to be_truthy
+        expect(config[:log_level]).to eq("debug")
       end
     end
 
@@ -501,6 +504,7 @@ describe Appsignal::Config do
       config[:log] = "stdout"
       config[:log_path] = "/tmp"
       config[:filter_parameters] = %w[password confirm_password]
+      config[:filter_session_data] = %w[key1 key2]
       config[:running_in_container] = false
       config[:dns_servers] = ["8.8.8.8", "8.8.4.4"]
       config[:transaction_debug_mode] = true
@@ -534,6 +538,8 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]).to       eq "true"
       expect(ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]).to       eq "true"
       expect(ENV["_APPSIGNAL_SEND_ENVIRONMENT_METADATA"]).to    eq "false"
+      expect(ENV["_APPSIGNAL_FILTER_PARAMETERS"]).to            eq "password,confirm_password"
+      expect(ENV["_APPSIGNAL_FILTER_SESSION_DATA"]).to          eq "key1,key2"
       expect(ENV["_APP_REVISION"]).to                           eq "v2.5.1"
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIR_PATH")
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIRECTORY_PATH")
@@ -780,4 +786,83 @@ describe Appsignal::Config do
       end
     end
   end
+
+  describe "#log_level" do
+    let(:options) { {} }
+    let(:config) { described_class.new("", nil, options) }
+    subject { config.log_level }
+
+    context "without any config" do
+      it "returns info by default" do
+        is_expected.to eq(Logger::INFO)
+      end
+    end
+
+    context "with debug set to true" do
+      let(:options) { { :debug => true } }
+      it { is_expected.to eq(Logger::DEBUG) }
+    end
+
+    context "with transaction_debug_mode set to true" do
+      let(:options) { { :transaction_debug_mode => true } }
+      it { is_expected.to eq(Logger::DEBUG) }
+    end
+
+    context "with log_level set to error" do
+      let(:options) { { :log_level => "error" } }
+      it { is_expected.to eq(Logger::ERROR) }
+    end
+
+    context "with log_level set to warn" do
+      let(:options) { { :log_level => "warn" } }
+      it { is_expected.to eq(Logger::WARN) }
+    end
+
+    context "with log_level set to info" do
+      let(:options) { { :log_level => "info" } }
+      it { is_expected.to eq(Logger::INFO) }
+    end
+
+    context "with log_level set to debug" do
+      let(:options) { { :log_level => "debug" } }
+      it { is_expected.to eq(Logger::DEBUG) }
+    end
+
+    context "with log_level set to trace" do
+      let(:options) { { :log_level => "trace" } }
+      it { is_expected.to eq(Logger::DEBUG) }
+    end
+
+    context "with debug and log_level set" do
+      let(:options) { { :log_level => "error", :debug => true } }
+
+      it "the log_level option is leading" do
+        is_expected.to eq(Logger::ERROR)
+      end
+    end
+
+    context "with transaction_debug_mode and log_level set" do
+      let(:options) { { :log_level => "error", :transaction_debug_mode => true } }
+
+      it "the log_level option is leading" do
+        is_expected.to eq(Logger::ERROR)
+      end
+    end
+
+    context "with log level set to an unknown value" do
+      let(:options) { { :log_level => "fatal" } }
+
+      it "prints a warning and doesn't use the log_level" do
+        is_expected.to eql(Logger::INFO)
+      end
+
+      context "with debug option set to true" do
+        let(:options) { { :log_level => "fatal", :debug => true } }
+
+        it "prints a warning and sets it to debug" do
+          is_expected.to eql(Logger::DEBUG)
+        end
+      end
+    end
+  end
 end

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

@@ -0,0 +1,23 @@
+describe Appsignal::Hooks::MriHook do
+  describe "#dependencies_present?" do
+    subject { described_class.new.dependencies_present? }
+
+    if DependencyHelper.running_jruby?
+      it { is_expected.to be_falsy }
+    else
+      it { is_expected.to be_truthy }
+    end
+  end
+
+  unless DependencyHelper.running_jruby?
+    context "install" do
+      before do
+        Appsignal::Hooks.load_hooks
+      end
+
+      it "should be added to minutely probes" do
+        expect(Appsignal::Minutely.probes[:mri]).to be Appsignal::Probes::MriProbe
+      end
+    end
+  end
+end

data/spec/lib/appsignal/probes/mri_spec.rb

@@ -0,0 +1,33 @@
+describe Appsignal::Probes::MriProbe do
+  let(:probe) { described_class.new }
+
+  describe ".dependencies_present?" do
+    if DependencyHelper.running_jruby? || DependencyHelper.running_ruby_2_0?
+      it "should not be present" do
+        expect(described_class.dependencies_present?).to be_falsy
+      end
+    else
+      it "should be present" do
+        expect(described_class.dependencies_present?).to be_truthy
+      end
+    end
+  end
+
+  unless DependencyHelper.running_jruby? || DependencyHelper.running_ruby_2_0?
+    describe "#call" do
+      it "should track vm metrics" do
+        expect_distribution_value(:class_serial)
+        expect_distribution_value(:global_constant_state)
+
+        probe.call
+      end
+    end
+
+    def expect_distribution_value(metric)
+      expect(Appsignal).to receive(:add_distribution_value)
+        .with("ruby_vm", kind_of(Numeric), :metric => metric)
+        .and_call_original
+        .once
+    end
+  end
+end

data/spec/lib/appsignal/span_spec.rb

@@ -0,0 +1,141 @@
+require "appsignal/span"
+
+describe Appsignal::Span do
+  before :context do
+    start_agent
+  end
+
+  let(:namespace) { "web" }
+  let(:root) { Appsignal::Span.new(namespace) }
+
+  describe "creating a span" do
+    it "creates an empty span" do
+      expect(root.to_h["namespace"]).to eq "web"
+      expect(root.to_h["trace_id"].length).to eq 16
+      expect(root.to_h["span_id"].length).to eq 8
+      expect(root.to_h["parent_span_id"]).to be_empty
+      expect(root.to_h["name"]).to be_empty
+      expect(root.to_h["start_time"]).to be > 1_600_000_000
+      expect(root.to_h["closed"]).to be false
+    end
+  end
+
+  describe "#child" do
+    let(:child) { root.child }
+
+    it "creates a child span" do
+      expect(child.to_h["namespace"]).to be_empty
+      expect(child.to_h["trace_id"].length).to eq 16
+      expect(child.to_h["span_id"].length).to eq 8
+      expect(child.to_h["parent_span_id"]).to eq root.to_h["span_id"]
+      expect(child.to_h["name"]).to be_empty
+      expect(child.to_h["start_time"]).to be > 1_600_000_000
+      expect(child.to_h["closed"]).to be false
+    end
+  end
+
+  describe "#add_error" do
+    it "adds an error" do
+      begin
+        raise "Error"
+      rescue => error
+        root.add_error(error)
+      end
+
+      error = root.to_h["error"]
+      expect(error["name"]).to eq "RuntimeError"
+      expect(error["message"]).to eq "Error"
+      expect(error["backtrace"]).not_to be_empty
+    end
+  end
+
+  describe "set_sample_data" do
+    it "sets sample data" do
+      root.set_sample_data(:params, "key" => "value")
+
+      sample_data = root.to_h["sample_data"]
+      expect(sample_data["params"]).to eq "{\"key\":\"value\"}"
+    end
+  end
+
+  describe "#name=" do
+    it "sets the name" do
+      root.name = "Span name"
+
+      expect(root.to_h["name"]).to eq "Span name"
+    end
+  end
+
+  describe "#[]=" do
+    let(:attributes) { root.to_h["attributes"] }
+
+    it "sets a string attribute" do
+      root["string"] = "attribute"
+
+      expect(attributes["string"]).to eq "attribute"
+    end
+
+    it "sets an integer attribute" do
+      root["integer"] = 1001
+
+      expect(attributes["integer"]).to eq 1001
+    end
+
+    it "sets a bigint attribute" do
+      root["bigint"] = 1 << 64
+
+      expect(attributes["bigint"]).to eq "bigint:#{1 << 64}"
+    end
+
+    it "sets a boolean attribute" do
+      root["true"] = true
+      root["false"] = false
+
+      expect(attributes["true"]).to eq true
+      expect(attributes["false"]).to eq false
+    end
+
+    it "sets a float attribute" do
+      root["float"] = 10.01
+
+      expect(attributes["float"]).to eq 10.01
+    end
+
+    it "raises an error for other types" do
+      expect do
+        root["something"] = Object.new
+      end.to raise_error TypeError
+    end
+  end
+
+  describe "#instrument" do
+    it "closes the span after yielding" do
+      root.instrument do
+        # Nothing happening
+      end
+      expect(root.closed?).to eq true
+    end
+
+    context "with an error raised in the passed block" do
+      it "closes the span after yielding" do
+        expect do
+          root.instrument do
+            raise ExampleException, "foo"
+          end
+        end.to raise_error(ExampleException, "foo")
+        expect(root.closed?).to eq true
+      end
+    end
+  end
+
+  describe "#close" do
+    it "closes a span" do
+      expect(root.closed?).to eq false
+
+      root.close
+
+      expect(root.to_h).to be_nil
+      expect(root.closed?).to eq true
+    end
+  end
+end