appsignal 3.0.15 → 3.0.16

data/lib/appsignal/extension/jruby.rb

@@ -131,6 +131,65 @@ module Appsignal
           [:pointer],
           :appsignal_string
 
+        # Span methods
+        attach_function :appsignal_create_root_span,
+          [:appsignal_string],
+          :pointer
+        attach_function :appsignal_create_root_span_with_timestamp,
+          [:appsignal_string, :int64, :int64],
+          :pointer
+        attach_function :appsignal_create_child_span,
+          [:pointer],
+          :pointer
+        attach_function :appsignal_create_child_span_with_timestamp,
+          [:pointer, :int64, :int64],
+          :pointer
+        attach_function :appsignal_create_span_from_traceparent,
+          [:appsignal_string],
+          :pointer
+        attach_function :appsignal_span_id,
+          [:pointer],
+          :appsignal_string
+        attach_function :appsignal_span_to_json,
+          [:pointer],
+          :appsignal_string
+        attach_function :appsignal_set_span_name,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_set_span_namespace,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_add_span_error,
+          [:pointer, :appsignal_string, :appsignal_string, :pointer],
+          :void
+        attach_function :appsignal_set_span_sample_data,
+          [:pointer, :appsignal_string, :pointer],
+          :void
+        attach_function :appsignal_set_span_attribute_string,
+          [:pointer, :appsignal_string, :appsignal_string],
+          :void
+        attach_function :appsignal_set_span_attribute_sql_string,
+          [:pointer, :appsignal_string, :appsignal_string],
+          :void
+        attach_function :appsignal_set_span_attribute_int,
+          [:pointer, :appsignal_string, :int64],
+          :void
+        attach_function :appsignal_set_span_attribute_bool,
+          [:pointer, :appsignal_string, :bool],
+          :void
+        attach_function :appsignal_set_span_attribute_double,
+          [:pointer, :appsignal_string, :double],
+          :void
+        attach_function :appsignal_close_span,
+          [:pointer],
+          :void
+        attach_function :appsignal_close_span_with_timestamp,
+          [:pointer, :int64, :int64],
+          :void
+        attach_function :appsignal_free_span,
+          [:pointer],
+          :void
+
         # Data struct methods
         attach_function :appsignal_free_data, [], :void
         attach_function :appsignal_data_map_new, [], :pointer
@@ -375,6 +434,94 @@ module Appsignal
         end
       end
 
+      class Span
+        include StringHelpers
+        extend StringHelpers
+
+        attr_reader :pointer
+
+        def initialize(pointer)
+          @pointer = FFI::AutoPointer.new(
+            pointer,
+            Extension.method(:appsignal_free_span)
+          )
+        end
+
+        def self.root(namespace)
+          namespace = make_appsignal_string(namespace)
+          Span.new(Extension.appsignal_create_root_span(namespace))
+        end
+
+        def child
+          Span.new(Extension.appsignal_create_child_span(pointer))
+        end
+
+        def add_error(name, message, backtrace)
+          Extension.appsignal_add_span_error(
+            pointer,
+            make_appsignal_string(name),
+            make_appsignal_string(message),
+            backtrace.pointer
+          )
+        end
+
+        def set_sample_data(key, payload)
+          Extension.appsignal_set_span_sample_data(
+            pointer,
+            make_appsignal_string(key),
+            payload.pointer
+          )
+        end
+
+        def set_name(name) # rubocop:disable Naming/AccessorMethodName
+          Extension.appsignal_set_span_name(
+            pointer,
+            make_appsignal_string(name)
+          )
+        end
+
+        def set_attribute_string(key, value)
+          Extension.appsignal_set_span_attribute_string(
+            pointer,
+            make_appsignal_string(key),
+            make_appsignal_string(value)
+          )
+        end
+
+        def set_attribute_int(key, value)
+          Extension.appsignal_set_span_attribute_int(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def set_attribute_bool(key, value)
+          Extension.appsignal_set_span_attribute_bool(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def set_attribute_double(key, value)
+          Extension.appsignal_set_span_attribute_double(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def to_json
+          json = Extension.appsignal_span_to_json(pointer)
+          make_ruby_string(json) if json[:len] > 0
+        end
+
+        def close
+          Extension.appsignal_close_span(pointer)
+        end
+      end
+
       class Data
         include StringHelpers
         attr_reader :pointer

data/lib/appsignal/extension.rb

@@ -60,6 +60,11 @@ module Appsignal
       # Makes sure the generated docs aren't always overwritten with the JRuby
       # version.
       Transaction = Jruby::Transaction
+      # Reassign Span class for JRuby extension usage.
+      #
+      # Makes sure the generated docs aren't always overwritten with the JRuby
+      # version.
+      Span = Jruby::Span
       # Reassign Data class for JRuby extension usage.
       #
       # Makes sure the generated docs aren't always overwritten with the JRuby

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.15".freeze
+  VERSION = "3.0.16".freeze
 end

data/script/lint_git

@@ -2,7 +2,7 @@
 
 set -eu
 
-LINTJE_VERSION="0.5.0"
+LINTJE_VERSION="0.6.1"
 
 mkdir -p $HOME/bin
 cache_key=v1-lintje-$LINTJE_VERSION

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

@@ -750,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
@@ -785,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
@@ -793,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
@@ -810,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)
@@ -904,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
@@ -1007,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
 
@@ -1015,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,34 +151,35 @@ 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",
+        :log_level                      => "info",
         :name                           => "TestApp",
-        :active                         => true,
-        :enable_allocation_tracking     => true,
-        :enable_gc_instrumentation      => false,
-        :enable_host_metrics            => true,
-        :enable_minutely_probes         => true,
-        :enable_statsd                  => 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
 
@@ -319,13 +320,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
 
@@ -502,6 +505,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
@@ -535,6 +539,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")

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

data/spec/lib/appsignal/transaction_spec.rb

@@ -1341,6 +1341,31 @@ describe Appsignal::Transaction do
     end
   end
 
+  describe "#cleaned_error_message" do
+    let(:error) { StandardError.new("Error message") }
+    subject { transaction.send(:cleaned_error_message, error) }
+
+    it "returns the error message" do
+      expect(subject).to eq "Error message"
+    end
+
+    context "with a PG::UniqueViolation" do
+      module PG
+        class UniqueViolation < StandardError; end
+      end
+
+      let(:error) do
+        PG::UniqueViolation.new(
+          "ERROR: duplicate key value violates unique constraint \"index_users_on_email\" DETAIL: Key (email)=(test@test.com) already exists."
+        )
+      end
+
+      it "returns a sanizited error message" do
+        expect(subject).to eq "ERROR: duplicate key value violates unique constraint \"index_users_on_email\" DETAIL: Key (email)=(?) already exists."
+      end
+    end
+  end
+
   describe ".to_hash / .to_h" do
     subject { transaction.to_hash }