appsignal 2.4.3 → 2.5.0.alpha.1

data/gemfiles/sequel-435.gemfile

@@ -1,7 +1,11 @@
 source 'https://rubygems.org'
 
 gem 'sequel', '~> 4.35'
-gem 'sqlite3'
+if RUBY_PLATFORM == "java"
+  gem 'jdbc-sqlite3'
+else
+  gem 'sqlite3'
+end
 gem 'rack', '~> 1.6'
 
 gemspec :path => '../'

data/gemfiles/sequel.gemfile

@@ -1,7 +1,11 @@
 source 'https://rubygems.org'
 
 gem 'sequel', '< 4.35'
-gem 'sqlite3'
+if RUBY_PLATFORM == "java"
+  gem 'jdbc-sqlite3'
+else
+  gem 'sqlite3'
+end
 gem 'rack', '~> 1.6'
 
 gemspec :path => '../'

data/lib/appsignal.rb

@@ -63,6 +63,11 @@ module Appsignal
       end
     end
 
+    # @api private
+    def testing?
+      false
+    end
+
     # Start the AppSignal integration.
     #
     # Starts AppSignal with the given configuration. If no configuration is set
@@ -88,7 +93,7 @@ module Appsignal
     #
     # @return [void]
     # @since 0.7.0
-    def start
+    def start # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       unless extension_loaded?
         logger.info("Not starting appsignal, extension is not loaded")
         return
@@ -119,7 +124,7 @@ module Appsignal
           Appsignal::EventFormatter.initialize_formatters
           initialize_extensions
 
-          if config[:enable_allocation_tracking]
+          if config[:enable_allocation_tracking] && !Appsignal::System.jruby?
             Appsignal::Extension.install_allocation_event_hook
           end
 
@@ -553,7 +558,7 @@ module Appsignal
     #   {.instrument_sql} instead of {EventFormatter::SQL_BODY_FORMAT}.
     # @yield yields the given block of code instrumented in an AppSignal
     #   event.
-    # @return [Object] Returns the blocks return value.
+    # @return [Object] Returns the block's return value.
     #
     # @see Appsignal::Transaction#instrument
     # @see .instrument_sql
@@ -588,7 +593,7 @@ module Appsignal
     # @param title [String, nil] Human readable name of the event.
     # @param body [String, nil] SQL query that's being executed.
     # @yield yields the given block of code instrumented in an AppSignal event.
-    # @return [Object] Returns the blocks return value.
+    # @return [Object] Returns the block's return value.
     #
     # @see .instrument
     # @see http://docs.appsignal.com/ruby/instrumentation/instrumentation.html
@@ -698,7 +703,7 @@ module Appsignal
     # @see Extension
     # @since 1.0.0
     def extension_loaded?
-      !!@extension_loaded
+      !!extension_loaded
     end
 
     # Returns the active state of the AppSignal integration.
@@ -778,6 +783,7 @@ module Appsignal
   end
 end
 
+require "appsignal/system"
 require "appsignal/utils"
 require "appsignal/extension"
 require "appsignal/auth_check"
@@ -796,4 +802,3 @@ require "appsignal/rack/generic_instrumentation"
 require "appsignal/rack/js_exception_catcher"
 require "appsignal/js_exception_transaction"
 require "appsignal/transmitter"
-require "appsignal/system"

data/lib/appsignal/cli.rb

@@ -1,6 +1,5 @@
 require "optparse"
 require "logger"
-require "yaml"
 require "appsignal"
 require "appsignal/cli/helpers"
 require "appsignal/cli/demo"
@@ -11,7 +10,7 @@ require "appsignal/cli/notify_of_deploy"
 module Appsignal
   # @api private
   class CLI
-    AVAILABLE_COMMANDS = %w(demo diagnose install notify_of_deploy).freeze
+    AVAILABLE_COMMANDS = %w[demo diagnose install notify_of_deploy].freeze
 
     class << self
       attr_accessor :options

data/lib/appsignal/cli/install.rb

@@ -92,7 +92,7 @@ module Appsignal
           puts "Installing for Sinatra"
           config[:name] = required_input("  Enter application name: ")
           puts
-          configure(config, %w(development production staging), true)
+          configure(config, %w[development production staging], true)
 
           puts "Finish Sinatra configuration"
           puts "  Sinatra requires some manual configuration."
@@ -110,7 +110,7 @@ module Appsignal
           puts "Installing for Padrino"
           config[:name] = required_input("  Enter application name: ")
           puts
-          configure(config, %w(development production staging), true)
+          configure(config, %w[development production staging], true)
 
           puts "Finish Padrino installation"
           puts "  Padrino requires some manual configuration."
@@ -130,7 +130,7 @@ module Appsignal
           config[:name] = required_input("  Enter application name: ")
           puts
 
-          configure(config, %w(development production staging), true)
+          configure(config, %w[development production staging], true)
 
           puts "Manual Grape configuration needed"
           puts "  See the installation instructions at:"

data/lib/appsignal/config.rb

@@ -63,6 +63,12 @@ module Appsignal
       "APPSIGNAL_FILES_WORLD_ACCESSIBLE"         => :files_world_accessible
     }.freeze
 
+    # Mapping of old and deprecated AppSignal configuration keys
+    DEPRECATED_CONFIG_KEY_MAPPING = {
+      :api_key => :push_api_key,
+      :ignore_exceptions => :ignore_errors
+    }.freeze
+
     attr_reader :root_path, :env, :initial_config, :config_hash
     attr_accessor :logger
 
@@ -161,6 +167,26 @@ module Appsignal
       ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]       = config_hash[:files_world_accessible].to_s
     end
 
+    def validate
+      # Strip path from endpoint so we're backwards compatible with
+      # earlier versions of the gem.
+      # TODO: Move to its own method, maybe in `#[]=`?
+      endpoint_uri = URI(config_hash[:endpoint])
+      config_hash[:endpoint] =
+        if endpoint_uri.port == 443
+          "#{endpoint_uri.scheme}://#{endpoint_uri.host}"
+        else
+          "#{endpoint_uri.scheme}://#{endpoint_uri.host}:#{endpoint_uri.port}"
+        end
+
+      if config_hash[:push_api_key]
+        @valid = true
+      else
+        @valid = false
+        @logger.error "Push api key not set after loading config"
+      end
+    end
+
     private
 
     def config_file
@@ -181,18 +207,12 @@ module Appsignal
       configurations = YAML.load(ERB.new(IO.read(config_file)).result)
       config_for_this_env = configurations[env]
       if config_for_this_env
-        config_for_this_env = Hash[config_for_this_env.map do |key, value|
-          [key.to_sym, value]
-        end] # convert keys to symbols
-
-        # Backwards compatibility with config files generated by earlier
-        # versions of the gem
-        if !config_for_this_env[:push_api_key] && config_for_this_env[:api_key]
-          config_for_this_env[:push_api_key] = config_for_this_env[:api_key]
-        end
-        if !config_for_this_env[:ignore_errors] && config_for_this_env[:ignore_exceptions]
-          config_for_this_env[:ignore_errors] = config_for_this_env[:ignore_exceptions]
-        end
+        config_for_this_env =
+          config_for_this_env.each_with_object({}) do |(key, value), hash|
+            hash[key.to_sym] = value # convert keys to symbols
+          end
+
+        config_for_this_env = maintain_backwards_compatibility(config_for_this_env)
 
         merge(@config_hash, config_for_this_env)
       else
@@ -200,35 +220,53 @@ module Appsignal
       end
     end
 
+    # Maintain backwards compatibility with config files generated by earlier
+    # versions of the gem
+    #
+    # Used by {#load_from_disk}. No compatibility for env variables or initial config currently.
+    def maintain_backwards_compatibility(configuration)
+      configuration.tap do |config|
+        DEPRECATED_CONFIG_KEY_MAPPING.each do |old_key, new_key|
+          old_config_value = config.delete(old_key)
+          next unless old_config_value
+          logger.warn "Old configuration key found. Please update the "\
+            "'#{old_key}' to '#{new_key}'."
+
+          next if config[new_key] # Skip if new key is already in use
+          config[new_key] = old_config_value
+        end
+      end
+    end
+
     def load_from_environment
       config = {}
 
       # Configuration with string type
-      %w(APPSIGNAL_PUSH_API_KEY APPSIGNAL_APP_NAME APPSIGNAL_PUSH_API_ENDPOINT
+      %w[APPSIGNAL_PUSH_API_KEY APPSIGNAL_APP_NAME APPSIGNAL_PUSH_API_ENDPOINT
          APPSIGNAL_FRONTEND_ERROR_CATCHING_PATH APPSIGNAL_HTTP_PROXY
          APPSIGNAL_LOG APPSIGNAL_LOG_PATH APPSIGNAL_WORKING_DIR_PATH
-         APPSIGNAL_HOSTNAME APPSIGNAL_CA_FILE_PATH).each do |var|
+         APPSIGNAL_HOSTNAME APPSIGNAL_CA_FILE_PATH].each do |var|
         env_var = ENV[var]
         next unless env_var
         config[ENV_TO_KEY_MAPPING[var]] = env_var
       end
 
       # Configuration with boolean type
-      %w(APPSIGNAL_ACTIVE APPSIGNAL_DEBUG APPSIGNAL_INSTRUMENT_NET_HTTP
+      %w[APPSIGNAL_ACTIVE APPSIGNAL_DEBUG APPSIGNAL_INSTRUMENT_NET_HTTP
          APPSIGNAL_INSTRUMENT_REDIS APPSIGNAL_INSTRUMENT_SEQUEL
          APPSIGNAL_SKIP_SESSION_DATA APPSIGNAL_ENABLE_FRONTEND_ERROR_CATCHING
          APPSIGNAL_ENABLE_ALLOCATION_TRACKING APPSIGNAL_ENABLE_GC_INSTRUMENTATION
          APPSIGNAL_RUNNING_IN_CONTAINER APPSIGNAL_ENABLE_HOST_METRICS
          APPSIGNAL_SEND_PARAMS APPSIGNAL_ENABLE_MINUTELY_PROBES
-         APPSIGNAL_FILES_WORLD_ACCESSIBLE).each do |var|
+         APPSIGNAL_FILES_WORLD_ACCESSIBLE].each do |var|
         env_var = ENV[var]
         next unless env_var
         config[ENV_TO_KEY_MAPPING[var]] = env_var.casecmp("true").zero?
       end
 
       # Configuration with array of strings type
-      %w(APPSIGNAL_IGNORE_ACTIONS APPSIGNAL_IGNORE_ERRORS
-         APPSIGNAL_IGNORE_NAMESPACES APPSIGNAL_FILTER_PARAMETERS).each do |var|
+      %w[APPSIGNAL_IGNORE_ACTIONS APPSIGNAL_IGNORE_ERRORS
+         APPSIGNAL_IGNORE_NAMESPACES APPSIGNAL_FILTER_PARAMETERS].each do |var|
         env_var = ENV[var]
         next unless env_var
         config[ENV_TO_KEY_MAPPING[var]] = env_var.split(",")
@@ -245,24 +283,5 @@ module Appsignal
         original_config[key] = value
       end
     end
-
-    def validate
-      # Strip path from endpoint so we're backwards compatible with
-      # earlier versions of the gem.
-      endpoint_uri = URI(config_hash[:endpoint])
-      config_hash[:endpoint] =
-        if endpoint_uri.port == 443
-          "#{endpoint_uri.scheme}://#{endpoint_uri.host}"
-        else
-          "#{endpoint_uri.scheme}://#{endpoint_uri.host}:#{endpoint_uri.port}"
-        end
-
-      if config_hash[:push_api_key]
-        @valid = true
-      else
-        @valid = false
-        @logger.error "Push api key not set after loading config"
-      end
-    end
   end
 end

data/lib/appsignal/extension.rb

@@ -1,12 +1,17 @@
 require "yaml"
 
 begin
-  require "appsignal_extension"
-  Appsignal.extension_loaded = true
+  if Appsignal::System.jruby?
+    require "appsignal/extension/jruby"
+    # {Appsignal.extension_loaded} is set in the jRuby extension file
+  else
+    require "appsignal_extension"
+    Appsignal.extension_loaded = true
+  end
 rescue LoadError => err
   Appsignal.logger.error(
     "Failed to load extension (#{err}), please check the install.log file in " \
-    "the ext directory of the gem and e-mail us at support@appsignal.com"
+    "the ext directory of the gem and email us at support@appsignal.com"
   )
   Appsignal.extension_loaded = false
 end
@@ -25,11 +30,30 @@ module Appsignal
         agent_config["version"]
       end
 
+      # Do nothing if the extension methods are not loaded
+      #
+      # Disabled in testing so we can make sure that we don't miss a extension
+      # function implementation.
       def method_missing(m, *args, &block)
-        # Do nothing if the extension methods are not loaded
+        super if Appsignal.testing?
       end
     end
 
+    if Appsignal::System.jruby?
+      extend Appsignal::Extension::Jruby
+
+      # Reassign Transaction class for jRuby extension usage.
+      #
+      # Makes sure the generated docs aren't always overwritten with the jRuby
+      # version.
+      Transaction = Jruby::Transaction
+      # Reassign Data class for jRuby extension usage.
+      #
+      # Makes sure the generated docs aren't always overwritten with the jRuby
+      # version.
+      Data = Jruby::Data
+    end
+
     class Data
       def inspect
         "#<#{self.class.name}:#{object_id} #{self}>"

data/lib/appsignal/extension/jruby.rb

@@ -0,0 +1,460 @@
+require "ffi"
+
+module Appsignal
+  class Extension
+    # jRuby extension wrapper
+    #
+    # Only loaded if the system is detected as jRuby.
+    #
+    # @api private
+    module Jruby # rubocop:disable Metrics/ModuleLength
+      extend FFI::Library
+
+      # jRuby extension String helpers.
+      #
+      # Based on the make_appsignal_string and make_ruby_string helpers from the
+      # AppSignal C-extension in `ext/appsignal_extension.c`.
+      module StringHelpers
+        class AppsignalString < FFI::Struct
+          layout :len, :size_t,
+            :buf, :pointer
+        end
+
+        def make_appsignal_string(ruby_string)
+          unless ruby_string.is_a?(String)
+            raise ArgumentError, "argument is not a string"
+          end
+
+          AppsignalString.new.tap do |appsignal_string|
+            appsignal_string[:len] = ruby_string.bytesize
+            appsignal_string[:buf] = FFI::MemoryPointer.from_string(ruby_string)
+          end
+        end
+
+        def make_ruby_string(appsignal_string)
+          appsignal_string[:buf].read_string(appsignal_string[:len]).tap do |ruby_string|
+            ruby_string.force_encoding(Encoding::UTF_8)
+          end
+        end
+      end
+      include StringHelpers
+
+      def self.lib_extension
+        if Appsignal::System.agent_platform.include?("darwin")
+          "dylib"
+        else
+          "so"
+        end
+      end
+
+      begin
+        ffi_lib File.join(File.dirname(__FILE__), "../../../ext/libappsignal.#{lib_extension}")
+        typedef AppsignalString.by_value, :appsignal_string
+
+        attach_function :appsignal_start, [], :void
+        attach_function :appsignal_stop, [], :void
+        attach_function :appsignal_diagnose, [], :appsignal_string
+        attach_function :appsignal_get_server_state,
+          [:appsignal_string],
+          :appsignal_string
+        attach_function :appsignal_running_in_container, [], :bool
+
+        # Metrics methods
+        attach_function :appsignal_set_gauge,
+          [:appsignal_string, :double],
+          :void
+        attach_function :appsignal_set_host_gauge,
+          [:appsignal_string, :double],
+          :void
+        attach_function :appsignal_set_process_gauge,
+          [:appsignal_string, :double],
+          :void
+        attach_function :appsignal_increment_counter,
+          [:appsignal_string, :int64],
+          :void
+        attach_function :appsignal_add_distribution_value,
+          [:appsignal_string, :double],
+          :void
+
+        # Transaction methods
+        attach_function :appsignal_free_transaction,
+          [],
+          :void
+        attach_function :appsignal_start_transaction,
+          [:appsignal_string, :appsignal_string, :long],
+          :pointer
+        attach_function :appsignal_start_event,
+          [:pointer, :long],
+          :void
+        attach_function :appsignal_finish_event,
+          [:pointer, :appsignal_string, :appsignal_string, :appsignal_string, :int64, :long],
+          :void
+        attach_function :appsignal_finish_event_data,
+          [:pointer, :appsignal_string, :appsignal_string, :pointer, :int64, :long],
+          :void
+        attach_function :appsignal_record_event,
+          [:pointer, :appsignal_string, :appsignal_string, :appsignal_string, :int64, :long, :long],
+          :void
+        attach_function :appsignal_record_event_data,
+          [:pointer, :appsignal_string, :appsignal_string, :pointer, :int64, :long, :long],
+          :void
+        attach_function :appsignal_set_transaction_error,
+          [:pointer, :appsignal_string, :appsignal_string, :pointer],
+          :void
+        attach_function :appsignal_set_transaction_action,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_set_transaction_namespace,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_set_transaction_sample_data,
+          [:pointer, :appsignal_string, :pointer],
+          :void
+        attach_function :appsignal_set_transaction_queue_start,
+          [:pointer, :long],
+          :void
+        attach_function :appsignal_set_transaction_metadata,
+          [:pointer, :appsignal_string, :appsignal_string],
+          :void
+        attach_function :appsignal_finish_transaction,
+          [:pointer, :long],
+          :void
+        attach_function :appsignal_complete_transaction,
+          [:pointer],
+          :void
+        attach_function :appsignal_transaction_to_json,
+          [:pointer],
+          :appsignal_string
+
+        # Data struct methods
+        attach_function :appsignal_free_data, [], :void
+        attach_function :appsignal_data_map_new, [], :pointer
+        attach_function :appsignal_data_array_new, [], :pointer
+        attach_function :appsignal_data_map_set_string,
+          [:pointer, :appsignal_string, :appsignal_string],
+          :void
+        attach_function :appsignal_data_map_set_integer,
+          [:pointer, :appsignal_string, :int64],
+          :void
+        attach_function :appsignal_data_map_set_float,
+          [:pointer, :appsignal_string, :double],
+          :void
+        attach_function :appsignal_data_map_set_boolean,
+          [:pointer, :appsignal_string, :bool],
+          :void
+        attach_function :appsignal_data_map_set_null,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_data_map_set_data,
+          [:pointer, :appsignal_string, :pointer],
+          :void
+        attach_function :appsignal_data_array_append_string,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_data_array_append_integer,
+          [:pointer, :int64],
+          :void
+        attach_function :appsignal_data_array_append_float,
+          [:pointer, :double],
+          :void
+        attach_function :appsignal_data_array_append_boolean,
+          [:pointer, :bool],
+          :void
+        attach_function :appsignal_data_array_append_null,
+          [:pointer],
+          :void
+        attach_function :appsignal_data_array_append_data,
+          [:pointer, :pointer],
+          :void
+        attach_function :appsignal_data_equal,
+          [:pointer, :pointer],
+          :bool
+        attach_function :appsignal_data_to_json,
+          [:pointer],
+          :appsignal_string
+
+        Appsignal.extension_loaded = true
+      rescue LoadError => err
+        Appsignal.logger.error(
+          "Failed to load extension (#{err}), please email us at " \
+          "support@appsignal.com"
+        )
+        Appsignal.extension_loaded = false
+      end
+
+      def start
+        appsignal_start
+      end
+
+      def stop
+        appsignal_stop
+      end
+
+      def diagnose
+        make_ruby_string(appsignal_diagnose)
+      end
+
+      def get_server_state(key)
+        state = appsignal_get_server_state(make_appsignal_string(key))
+        make_ruby_string state if state[:len] > 0
+      end
+
+      def start_transaction(transaction_id, namespace, gc_duration_ms)
+        transaction = appsignal_start_transaction(
+          make_appsignal_string(transaction_id),
+          make_appsignal_string(namespace),
+          gc_duration_ms
+        )
+
+        return if !transaction || transaction.null?
+        Transaction.new(transaction)
+      end
+
+      def data_map_new
+        Data.new(appsignal_data_map_new)
+      end
+
+      def data_array_new
+        Data.new(appsignal_data_array_new)
+      end
+
+      def running_in_container?
+        appsignal_running_in_container
+      end
+
+      def set_gauge(key, value)
+        appsignal_set_gauge(make_appsignal_string(key), value)
+      end
+
+      def set_host_gauge(key, value)
+        appsignal_set_host_gauge(make_appsignal_string(key), value)
+      end
+
+      def set_process_gauge(key, value)
+        appsignal_set_process_gauge(make_appsignal_string(key), value)
+      end
+
+      def increment_counter(key, value)
+        appsignal_increment_counter(make_appsignal_string(key), value)
+      end
+
+      def add_distribution_value(key, value)
+        appsignal_add_distribution_value(make_appsignal_string(key), value)
+      end
+
+      class Transaction # rubocop:disable Metrics/ClassLength
+        include StringHelpers
+
+        attr_reader :pointer
+
+        def initialize(pointer)
+          @pointer = FFI::AutoPointer.new(
+            pointer,
+            Extension.method(:appsignal_free_transaction)
+          )
+        end
+
+        def start_event(gc_duration_ms)
+          Extension.appsignal_start_event(pointer, gc_duration_ms)
+        end
+
+        def finish_event(name, title, body, body_format, gc_duration_ms)
+          case body
+          when String
+            method = :appsignal_finish_event
+            body_arg = make_appsignal_string(body)
+          when Data
+            method = :appsignal_finish_event_data
+            body_arg = body.pointer
+          else
+            raise ArgumentError,
+              "body argument should be a String or Appsignal::Extension::Data"
+          end
+          Extension.public_send(
+            method,
+            pointer,
+            make_appsignal_string(name),
+            make_appsignal_string(title),
+            body_arg,
+            body_format,
+            gc_duration_ms
+          )
+        end
+
+        def record_event(name, title, body, body_format, duration, gc_duration_ms) # rubocop:disable Metrics/ParameterLists
+          case body
+          when String
+            method = :appsignal_record_event
+            body_arg = make_appsignal_string(body)
+          when Data
+            method = :appsignal_record_event_data
+            body_arg = body.pointer
+          else
+            raise ArgumentError,
+              "body argument should be a String or Appsignal::Extension::Data"
+          end
+          Extension.public_send(
+            method,
+            pointer,
+            make_appsignal_string(name),
+            make_appsignal_string(title),
+            body_arg,
+            body_format,
+            duration,
+            gc_duration_ms
+          )
+        end
+
+        def set_error(name, message, backtrace)
+          Extension.appsignal_set_transaction_error(
+            pointer,
+            make_appsignal_string(name),
+            make_appsignal_string(message),
+            backtrace.pointer
+          )
+        end
+
+        def set_action(action_name) # rubocop:disable Style/AccessorMethodName
+          Extension.appsignal_set_transaction_action(
+            pointer,
+            make_appsignal_string(action_name)
+          )
+        end
+
+        def set_namespace(namespace) # rubocop:disable Style/AccessorMethodName
+          Extension.appsignal_set_transaction_namespace(
+            pointer,
+            make_appsignal_string(namespace)
+          )
+        end
+
+        def set_sample_data(key, payload)
+          Extension.appsignal_set_transaction_sample_data(
+            pointer,
+            make_appsignal_string(key),
+            payload.pointer
+          )
+        end
+
+        def set_queue_start(time) # rubocop:disable Style/AccessorMethodName
+          Extension.appsignal_set_transaction_queue_start(pointer, time)
+        end
+
+        def set_metadata(key, value)
+          Extension.appsignal_set_transaction_metadata(
+            pointer,
+            make_appsignal_string(key),
+            make_appsignal_string(value)
+          )
+        end
+
+        def finish(gc_duration_ms)
+          Extension.appsignal_finish_transaction(pointer, gc_duration_ms)
+        end
+
+        def complete
+          Extension.appsignal_complete_transaction(pointer)
+        end
+
+        def to_json
+          json = Extension.appsignal_transaction_to_json(pointer)
+          make_ruby_string(json) if json[:len] > 0
+        end
+      end
+
+      class Data
+        include StringHelpers
+        attr_reader :pointer
+
+        def initialize(pointer)
+          @pointer = FFI::AutoPointer.new(
+            pointer,
+            Extension.method(:appsignal_free_data)
+          )
+        end
+
+        def set_string(key, value)
+          Extension.appsignal_data_map_set_string(
+            pointer,
+            make_appsignal_string(key),
+            make_appsignal_string(value)
+          )
+        end
+
+        def set_integer(key, value)
+          Extension.appsignal_data_map_set_integer(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def set_float(key, value)
+          Extension.appsignal_data_map_set_float(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def set_boolean(key, value)
+          Extension.appsignal_data_map_set_boolean(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def set_nil(key) # rubocop:disable Style/AccessorMethodName
+          Extension.appsignal_data_map_set_null(
+            pointer,
+            make_appsignal_string(key)
+          )
+        end
+
+        def set_data(key, value)
+          Extension.appsignal_data_map_set_data(
+            pointer,
+            make_appsignal_string(key),
+            value.pointer
+          )
+        end
+
+        def append_string(value)
+          Extension.appsignal_data_array_append_string(
+            pointer,
+            make_appsignal_string(value)
+          )
+        end
+
+        def append_integer(value)
+          Extension.appsignal_data_array_append_integer(pointer, value)
+        end
+
+        def append_float(value)
+          Extension.appsignal_data_array_append_float(pointer, value)
+        end
+
+        def append_boolean(value)
+          Extension.appsignal_data_array_append_boolean(pointer, value)
+        end
+
+        def append_nil
+          Extension.appsignal_data_array_append_null(pointer)
+        end
+
+        def append_data(value)
+          Extension.appsignal_data_array_append_data(pointer, value.pointer)
+        end
+
+        def ==(other)
+          Extension.appsignal_data_equal(pointer, other.pointer)
+        end
+
+        def to_s
+          make_ruby_string Extension.appsignal_data_to_json(pointer)
+        end
+      end
+    end
+  end
+end