appsignal 3.0.14-java → 3.0.18-java

data/lib/appsignal/cli/diagnose.rb

@@ -143,7 +143,7 @@ module Appsignal
         def transmit_report_to_appsignal
           puts "  Transmitting diagnostics report"
           transmitter = Transmitter.new(
-            DIAGNOSE_ENDPOINT,
+            ENV.fetch("APPSIGNAL_DIAGNOSE_ENDPOINT", DIAGNOSE_ENDPOINT),
             Appsignal.config
           )
           response = transmitter.transmit(:diagnose => data)
@@ -171,11 +171,18 @@ module Appsignal
           puts_value label, value
         end
 
+        # Prints values as given. Does no formatting on the value
         def puts_value(label, value, options = {})
           options[:level] ||= 1
           puts "#{"  " * options[:level]}#{label}: #{value}"
         end
 
+        # Print values as inspected.
+        # Surrounds Strings in quotes.
+        def puts_format(label, value, options = {})
+          puts_value label, value.inspect, options
+        end
+
         def configure_appsignal(options)
           current_path = Dir.pwd
           initial_config = {}
@@ -327,9 +334,18 @@ module Appsignal
           data_section :library do
             save :language, "ruby"
             puts_value "Language", "Ruby"
-            puts_and_save :package_version, "Gem version", Appsignal::VERSION
-            puts_and_save :agent_version, "Agent version", Appsignal::Extension.agent_version
-            puts_and_save :extension_loaded, "Extension loaded", Appsignal.extension_loaded
+
+            package_version = Appsignal::VERSION
+            save :package_version, package_version
+            puts_format "Gem version", package_version
+
+            agent_version = Appsignal::Extension.agent_version
+            save :agent_version, agent_version
+            puts_format "Agent version", agent_version
+
+            extension_loaded = Appsignal.extension_loaded
+            save :extension_loaded, extension_loaded
+            puts_format "Extension loaded", extension_loaded
           end
         end
 
@@ -381,29 +397,29 @@ module Appsignal
         def print_installation_language_report(report)
           report = report.fetch("language", {})
           puts "  Language details"
-          puts "    Implementation: #{report["implementation"]}"
-          puts "    Ruby version: #{report["version"]}"
+          puts_format "Implementation", report["implementation"], :level => 2
+          puts_format "Ruby version", report["version"], :level => 2
         end
 
         def print_installation_download_report(report)
           report = report.fetch("download", {})
           puts "  Download details"
-          puts "    Download URL: #{report["download_url"]}"
-          puts "    Checksum: #{report["checksum"]}"
+          puts_format "Download URL", report["download_url"], :level => 2
+          puts_format "Checksum", report["checksum"], :level => 2
         end
 
         def print_installation_build_report(report)
           report = report.fetch("build", {})
           puts "  Build details"
-          puts "    Install time: #{report["time"]}"
-          puts "    Architecture: #{report["architecture"]}"
-          puts "    Target: #{report["target"]}"
-          puts "    Musl override: #{report["musl_override"]}"
-          puts "    Linux ARM override: #{report["linux_arm_override"]}"
-          puts "    Library type: #{report["library_type"]}"
-          puts "    Source: #{report["source"]}" if report["source"] != "remote"
-          puts "    Dependencies: #{report["dependencies"]}"
-          puts "    Flags: #{report["flags"]}"
+          puts_format "Install time", report["time"].to_s, :level => 2
+          puts_format "Architecture", report["architecture"], :level => 2
+          puts_format "Target", report["target"], :level => 2
+          puts_format "Musl override", report["musl_override"], :level => 2
+          puts_format "Linux ARM override", report["linux_arm_override"], :level => 2
+          puts_format "Library type", report["library_type"], :level => 2
+          puts_format "Source", report["source"], :level => 2 if report["source"] != "remote"
+          puts_format "Dependencies", report["dependencies"], :level => 2
+          puts_format "Flags", report["flags"], :level => 2
         end
 
         def print_installation_host_report(report)
@@ -417,24 +433,31 @@ module Appsignal
           rbconfig = RbConfig::CONFIG
           puts "Host information"
           data_section :host do
-            puts_and_save :architecture, "Architecture", Appsignal::System.agent_architecture
+            agent_architecture = Appsignal::System.agent_architecture
+            save :architecture, agent_architecture
+            puts_format "Architecture", agent_architecture
 
-            os_label = os = rbconfig["host_os"]
-            os_label = "#{os} (Microsoft Windows is not supported.)" if Gem.win_platform?
+            os = rbconfig["host_os"]
+            os_label = os.inspect
+            os_label = "#{os_label} (Microsoft Windows is not supported.)" if Gem.win_platform?
             save :os, os
             puts_value "Operating System", os_label
 
-            puts_and_save :language_version, "Ruby version",
-              "#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}"
+            language_version = "#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}"
+            save :language_version, language_version
+            puts_format "Ruby version", language_version
 
-            puts_value "Heroku", "true" if Appsignal::System.heroku?
-            save :heroku, Appsignal::System.heroku?
+            heroku = Appsignal::System.heroku?
+            save :heroku, heroku
+            puts_format "Heroku", true if Appsignal::System.heroku?
 
-            save :root, Process.uid.zero?
-            puts_value "Root user",
-              Process.uid.zero? ? "true (not recommended)" : "false"
-            puts_and_save :running_in_container, "Running in container",
-              Appsignal::Extension.running_in_container?
+            root = Process.uid.zero?
+            save :root, root
+            puts_value "Root user", root ? "true (not recommended)" : "false"
+
+            running_in_container = Appsignal::Extension.running_in_container?
+            save :running_in_container, running_in_container
+            puts_format "Running in container", running_in_container
           end
         end
 
@@ -451,7 +474,6 @@ module Appsignal
               :env => config.env_config
             }
           }
-          print_environment(config)
           print_config_options(config)
         end
 
@@ -460,7 +482,7 @@ module Appsignal
           option = :env
           option_sources = sources_for_option(option)
           sources_label = config_sources_label(option, option_sources)
-          print "  Environment: #{format_config_option(env)}"
+          print "  environment: #{format_config_option(env)}"
 
           if env == ""
             message = "    Warning: No environment set, no config loaded!\n" \
@@ -474,10 +496,22 @@ module Appsignal
         end
 
         def print_config_options(config)
-          config.config_hash.each do |key, value|
+          # We add the nullified "environment" key to print it ordered
+          # instead of adding it at the top of the list.
+          ordered_config_options = config
+            .config_hash
+            .merge(:environment => nil)
+            .sort
+
+          ordered_config_options.each do |key, value|
             option_sources = sources_for_option(key)
             sources_label = config_sources_label(key, option_sources)
-            puts "  #{key}: #{format_config_option(value)}#{sources_label}"
+
+            if key == :environment
+              print_environment(config)
+            else
+              puts "  #{key}: #{format_config_option(value)}#{sources_label}"
+            end
           end
 
           puts "\nRead more about how the diagnose config output is rendered\n"\
@@ -543,7 +577,7 @@ module Appsignal
             when "401"
               ["invalid", :red]
             else
-              ["Failed with status #{status}\n#{error.inspect}", :red]
+              ["Failed to validate: status #{status}\n#{error.inspect}", :red]
             end
           data[:validation][:push_api_key] = result
           puts_value "Validating Push API key", colorize(result, color)
@@ -563,6 +597,7 @@ module Appsignal
 
           unless path[:exists]
             puts_value "Exists?", path[:exists], :level => 2
+            print_empty_line
             return
           end
 

data/lib/appsignal/config.rb

@@ -11,15 +11,25 @@ module Appsignal
     include Appsignal::Utils::DeprecationMessage
 
     DEFAULT_CONFIG = {
+      :ca_file_path                   => File.expand_path(File.join("../../../resources/cacert.pem"), __FILE__),
       :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            => [],
-      :send_environment_metadata      => true,
-      :send_params                    => true,
+      :instrument_net_http            => true,
+      :instrument_redis               => true,
+      :instrument_sequel              => true,
+      :log                            => "file",
       :request_headers                => %w[
         HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING
         HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL HTTP_CONNECTION
@@ -27,56 +37,61 @@ module Appsignal
         REQUEST_METHOD REQUEST_URI SERVER_NAME SERVER_PORT
         SERVER_PROTOCOL
       ],
-      :endpoint                       => "https://push.appsignal.com",
-      :instrument_net_http            => true,
-      :instrument_redis               => true,
-      :instrument_sequel              => true,
+      :send_environment_metadata      => true,
+      :send_params                    => true,
       :skip_session_data              => false,
-      :enable_allocation_tracking     => true,
-      :enable_gc_instrumentation      => false,
-      :enable_host_metrics            => true,
-      :enable_minutely_probes         => true,
-      :enable_statsd                  => true,
-      :ca_file_path                   => File.expand_path(File.join("../../../resources/cacert.pem"), __FILE__),
-      :dns_servers                    => [],
-      :files_world_accessible         => true,
       :transaction_debug_mode         => false
     }.freeze
 
+    # @api private
+    DEFAULT_LOG_LEVEL = Logger::INFO
+    # Map from the `log_level` config option to Ruby's Logger level value.
+    #
+    # The trace level doesn't exist in the Ruby logger so it's mapped to debug.
+    # @api private
+    LOG_LEVEL_MAP = {
+      "error" => Logger::ERROR,
+      "warn" => Logger::WARN,
+      "info" => Logger::INFO,
+      "debug" => Logger::DEBUG,
+      "trace" => Logger::DEBUG
+    }.freeze
+
     ENV_TO_KEY_MAPPING = {
       "APPSIGNAL_ACTIVE"                         => :active,
-      "APPSIGNAL_PUSH_API_KEY"                   => :push_api_key,
       "APPSIGNAL_APP_NAME"                       => :name,
-      "APPSIGNAL_PUSH_API_ENDPOINT"              => :endpoint,
+      "APPSIGNAL_CA_FILE_PATH"                   => :ca_file_path,
       "APPSIGNAL_DEBUG"                          => :debug,
-      "APPSIGNAL_LOG"                            => :log,
-      "APPSIGNAL_LOG_PATH"                       => :log_path,
-      "APPSIGNAL_INSTRUMENT_NET_HTTP"            => :instrument_net_http,
-      "APPSIGNAL_INSTRUMENT_REDIS"               => :instrument_redis,
-      "APPSIGNAL_INSTRUMENT_SEQUEL"              => :instrument_sequel,
-      "APPSIGNAL_SKIP_SESSION_DATA"              => :skip_session_data,
-      "APPSIGNAL_IGNORE_ACTIONS"                 => :ignore_actions,
-      "APPSIGNAL_IGNORE_ERRORS"                  => :ignore_errors,
-      "APPSIGNAL_IGNORE_NAMESPACES"              => :ignore_namespaces,
-      "APPSIGNAL_FILTER_PARAMETERS"              => :filter_parameters,
-      "APPSIGNAL_FILTER_SESSION_DATA"            => :filter_session_data,
-      "APPSIGNAL_SEND_ENVIRONMENT_METADATA"      => :send_environment_metadata,
-      "APPSIGNAL_SEND_PARAMS"                    => :send_params,
-      "APPSIGNAL_HTTP_PROXY"                     => :http_proxy,
+      "APPSIGNAL_DNS_SERVERS"                    => :dns_servers,
       "APPSIGNAL_ENABLE_ALLOCATION_TRACKING"     => :enable_allocation_tracking,
       "APPSIGNAL_ENABLE_GC_INSTRUMENTATION"      => :enable_gc_instrumentation,
-      "APPSIGNAL_RUNNING_IN_CONTAINER"           => :running_in_container,
-      "APPSIGNAL_WORKING_DIR_PATH"               => :working_dir_path,
-      "APPSIGNAL_WORKING_DIRECTORY_PATH"         => :working_directory_path,
       "APPSIGNAL_ENABLE_HOST_METRICS"            => :enable_host_metrics,
       "APPSIGNAL_ENABLE_MINUTELY_PROBES"         => :enable_minutely_probes,
       "APPSIGNAL_ENABLE_STATSD"                  => :enable_statsd,
-      "APPSIGNAL_HOSTNAME"                       => :hostname,
-      "APPSIGNAL_CA_FILE_PATH"                   => :ca_file_path,
-      "APPSIGNAL_DNS_SERVERS"                    => :dns_servers,
       "APPSIGNAL_FILES_WORLD_ACCESSIBLE"         => :files_world_accessible,
+      "APPSIGNAL_FILTER_PARAMETERS"              => :filter_parameters,
+      "APPSIGNAL_FILTER_SESSION_DATA"            => :filter_session_data,
+      "APPSIGNAL_HOSTNAME"                       => :hostname,
+      "APPSIGNAL_HTTP_PROXY"                     => :http_proxy,
+      "APPSIGNAL_IGNORE_ACTIONS"                 => :ignore_actions,
+      "APPSIGNAL_IGNORE_ERRORS"                  => :ignore_errors,
+      "APPSIGNAL_IGNORE_NAMESPACES"              => :ignore_namespaces,
+      "APPSIGNAL_INSTRUMENT_NET_HTTP"            => :instrument_net_http,
+      "APPSIGNAL_INSTRUMENT_REDIS"               => :instrument_redis,
+      "APPSIGNAL_INSTRUMENT_SEQUEL"              => :instrument_sequel,
+      "APPSIGNAL_LOG"                            => :log,
+      "APPSIGNAL_LOG_LEVEL"                      => :log_level,
+      "APPSIGNAL_LOG_PATH"                       => :log_path,
+      "APPSIGNAL_PUSH_API_ENDPOINT"              => :endpoint,
+      "APPSIGNAL_PUSH_API_KEY"                   => :push_api_key,
       "APPSIGNAL_REQUEST_HEADERS"                => :request_headers,
+      "APPSIGNAL_RUNNING_IN_CONTAINER"           => :running_in_container,
+      "APPSIGNAL_SEND_ENVIRONMENT_METADATA"      => :send_environment_metadata,
+      "APPSIGNAL_SEND_PARAMS"                    => :send_params,
+      "APPSIGNAL_SKIP_SESSION_DATA"              => :skip_session_data,
       "APPSIGNAL_TRANSACTION_DEBUG_MODE"         => :transaction_debug_mode,
+      "APPSIGNAL_WORKING_DIRECTORY_PATH"         => :working_directory_path,
+      "APPSIGNAL_WORKING_DIR_PATH"               => :working_dir_path,
       "APP_REVISION"                             => :revision
     }.freeze
     # @api private
@@ -86,6 +101,7 @@ module Appsignal
       APPSIGNAL_HOSTNAME
       APPSIGNAL_HTTP_PROXY
       APPSIGNAL_LOG
+      APPSIGNAL_LOG_LEVEL
       APPSIGNAL_LOG_PATH
       APPSIGNAL_PUSH_API_ENDPOINT
       APPSIGNAL_PUSH_API_KEY
@@ -239,6 +255,18 @@ module Appsignal
       config_hash[key] = value
     end
 
+    def log_level
+      if config_hash[:debug] || config_hash[:transaction_debug_mode]
+        level = Logger::DEBUG
+      end
+      option = config_hash[:log_level]
+      if option
+        log_level_option = LOG_LEVEL_MAP[option]
+        level = log_level_option if log_level_option
+      end
+      level.nil? ? Appsignal::Config::DEFAULT_LOG_LEVEL : level
+    end
+
     def log_file_path
       path = config_hash[:log_path] || root_path && File.join(root_path, "log")
       if path && File.writable?(path)
@@ -268,32 +296,35 @@ module Appsignal
 
     def write_to_environment # rubocop:disable Metrics/AbcSize
       ENV["_APPSIGNAL_ACTIVE"]                       = active?.to_s
-      ENV["_APPSIGNAL_APP_PATH"]                     = root_path.to_s
       ENV["_APPSIGNAL_AGENT_PATH"]                   = File.expand_path("../../../ext", __FILE__).to_s
+      ENV["_APPSIGNAL_APP_NAME"]                     = config_hash[:name]
+      ENV["_APPSIGNAL_APP_PATH"]                     = root_path.to_s
+      ENV["_APPSIGNAL_CA_FILE_PATH"]                 = config_hash[:ca_file_path].to_s
+      ENV["_APPSIGNAL_DEBUG_LOGGING"]                = config_hash[:debug].to_s
+      ENV["_APPSIGNAL_DNS_SERVERS"]                  = config_hash[:dns_servers].join(",")
+      ENV["_APPSIGNAL_ENABLE_HOST_METRICS"]          = config_hash[:enable_host_metrics].to_s
+      ENV["_APPSIGNAL_ENABLE_STATSD"]                = config_hash[:enable_statsd].to_s
       ENV["_APPSIGNAL_ENVIRONMENT"]                  = env
+      ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]       = config_hash[:files_world_accessible].to_s
+      ENV["_APPSIGNAL_FILTER_PARAMETERS"]            = config_hash[:filter_parameters].join(",")
+      ENV["_APPSIGNAL_FILTER_SESSION_DATA"]          = config_hash[:filter_session_data].join(",")
+      ENV["_APPSIGNAL_HOSTNAME"]                     = config_hash[:hostname].to_s
+      ENV["_APPSIGNAL_HTTP_PROXY"]                   = config_hash[:http_proxy]
+      ENV["_APPSIGNAL_IGNORE_ACTIONS"]               = config_hash[:ignore_actions].join(",")
+      ENV["_APPSIGNAL_IGNORE_ERRORS"]                = config_hash[:ignore_errors].join(",")
+      ENV["_APPSIGNAL_IGNORE_NAMESPACES"]            = config_hash[:ignore_namespaces].join(",")
       ENV["_APPSIGNAL_LANGUAGE_INTEGRATION_VERSION"] = "ruby-#{Appsignal::VERSION}"
-      ENV["_APPSIGNAL_DEBUG_LOGGING"]                = config_hash[:debug].to_s
       ENV["_APPSIGNAL_LOG"]                          = config_hash[:log]
+      ENV["_APPSIGNAL_LOG_LEVEL"]                    = config_hash[:log_level]
       ENV["_APPSIGNAL_LOG_FILE_PATH"]                = log_file_path.to_s if log_file_path
+      ENV["_APPSIGNAL_PROCESS_NAME"]                 = $PROGRAM_NAME
       ENV["_APPSIGNAL_PUSH_API_ENDPOINT"]            = config_hash[:endpoint]
       ENV["_APPSIGNAL_PUSH_API_KEY"]                 = config_hash[:push_api_key]
-      ENV["_APPSIGNAL_APP_NAME"]                     = config_hash[:name]
-      ENV["_APPSIGNAL_HTTP_PROXY"]                   = config_hash[:http_proxy]
-      ENV["_APPSIGNAL_IGNORE_ACTIONS"]               = config_hash[:ignore_actions].join(",")
-      ENV["_APPSIGNAL_IGNORE_ERRORS"]                = config_hash[:ignore_errors].join(",")
-      ENV["_APPSIGNAL_IGNORE_NAMESPACES"]            = config_hash[:ignore_namespaces].join(",")
       ENV["_APPSIGNAL_RUNNING_IN_CONTAINER"]         = config_hash[:running_in_container].to_s
-      ENV["_APPSIGNAL_WORKING_DIR_PATH"]             = config_hash[:working_dir_path] if config_hash[:working_dir_path]
-      ENV["_APPSIGNAL_WORKING_DIRECTORY_PATH"]       = config_hash[:working_directory_path] if config_hash[:working_directory_path]
-      ENV["_APPSIGNAL_ENABLE_HOST_METRICS"]          = config_hash[:enable_host_metrics].to_s
-      ENV["_APPSIGNAL_HOSTNAME"]                     = config_hash[:hostname].to_s
-      ENV["_APPSIGNAL_PROCESS_NAME"]                 = $PROGRAM_NAME
-      ENV["_APPSIGNAL_CA_FILE_PATH"]                 = config_hash[:ca_file_path].to_s
-      ENV["_APPSIGNAL_DNS_SERVERS"]                  = config_hash[:dns_servers].join(",")
-      ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]       = config_hash[:files_world_accessible].to_s
-      ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]       = config_hash[:transaction_debug_mode].to_s
       ENV["_APPSIGNAL_SEND_ENVIRONMENT_METADATA"]    = config_hash[:send_environment_metadata].to_s
-      ENV["_APPSIGNAL_ENABLE_STATSD"]                = config_hash[:enable_statsd].to_s
+      ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]       = config_hash[:transaction_debug_mode].to_s
+      ENV["_APPSIGNAL_WORKING_DIRECTORY_PATH"]       = config_hash[:working_directory_path] if config_hash[:working_directory_path]
+      ENV["_APPSIGNAL_WORKING_DIR_PATH"]             = config_hash[:working_dir_path] if config_hash[:working_dir_path]
       ENV["_APP_REVISION"]                           = config_hash[:revision].to_s
     end
 
@@ -339,7 +370,8 @@ module Appsignal
     def load_from_disk
       return if !config_file || !File.exist?(config_file)
 
-      configurations = YAML.load(ERB.new(IO.read(config_file)).result)
+      read_options = RUBY_VERSION >= "3.1.0" ? { :aliases => true } : {}
+      configurations = YAML.load(ERB.new(IO.read(config_file)).result, **read_options)
       config_for_this_env = configurations[env]
       if config_for_this_env
         config_for_this_env =

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/integrations/sidekiq.rb

@@ -158,7 +158,11 @@ module Appsignal
 
       # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L403-L412
       def safe_load(content, default)
-        yield(*YAML.load(content))
+        if RUBY_VERSION >= "3.1.0"
+          yield(*YAML.unsafe_load(content))
+        else
+          yield(*YAML.load(content))
+        end
       rescue => error
         # Sidekiq issue #1761: in dev mode, it's possible to have jobs enqueued
         # which haven't been loaded into memory yet so the YAML can't be