appsignal 2.5.0.alpha.1-java

data/appsignal.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path("../lib/appsignal/version", __FILE__)
+
+Gem::Specification.new do |gem| # rubocop:disable Metrics/BlockLength
+  gem.authors = [
+    "Robert Beekman",
+    "Thijs Cadier"
+  ]
+  gem.email                 = ["support@appsignal.com"]
+  gem.description           = "The official appsignal.com gem"
+  gem.summary               = "Logs performance and exception data from your app to "\
+                              "appsignal.com"
+  gem.homepage              = "https://github.com/appsignal/appsignal-ruby"
+  gem.license               = "MIT"
+
+  gem.files                 = `git ls-files`.split($\) # rubocop:disable Style/SpecialGlobalVars
+  gem.executables           = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files            = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name                  = "appsignal"
+  gem.require_paths         = %w[lib ext]
+  gem.version               = Appsignal::VERSION
+  gem.required_ruby_version = ">= 1.9"
+
+  if RUBY_PLATFORM == "java" || ENV["APPSIGNAL_PUSH_JAVA_GEM"]
+    gem.platform = "java"
+    gem.extensions = %w[ext/Rakefile]
+    gem.add_dependency "ffi"
+  else
+    gem.extensions = %w[ext/extconf.rb]
+  end
+
+  gem.add_dependency "rack"
+
+  gem.add_development_dependency "rake", "~> 11"
+  gem.add_development_dependency "rspec", "~> 3.6"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "timecop"
+  gem.add_development_dependency "webmock"
+  gem.add_development_dependency "rubocop", "0.49.0"
+  gem.add_development_dependency "yard"
+end

data/benchmark.rake

@@ -0,0 +1,77 @@
+require 'appsignal'
+require 'benchmark'
+
+GC.disable
+
+task :default => :'benchmark:all'
+
+namespace :benchmark do
+  task :all => [:run_inactive, :run_active]
+
+  task :run_inactive do
+    puts 'Running with appsignal off'
+    ENV['APPSIGNAL_PUSH_API_KEY'] = nil
+    run_benchmark
+  end
+
+  task :run_active do
+    puts 'Running with appsignal on'
+    ENV['APPSIGNAL_PUSH_API_KEY'] = 'something'
+    run_benchmark
+  end
+end
+
+def run_benchmark
+  no_transactions = (ENV['NO_TRANSACTIONS'] || 100_000).to_i
+  no_threads = (ENV['NO_THREADS'] || 1).to_i
+
+  total_objects = ObjectSpace.count_objects[:TOTAL]
+  puts "Initializing, currently #{total_objects} objects"
+
+  Appsignal.config = Appsignal::Config.new(Dir.pwd, 'production', :endpoint => 'http://localhost:8080')
+  Appsignal.start
+  puts "Appsignal #{Appsignal.active? ? 'active' : 'not active'}"
+
+  threads = []
+  puts "Running #{no_transactions} normal transactions in #{no_threads} threads"
+  puts(Benchmark.measure do
+    no_threads.times do
+      thread = Thread.new do
+        no_transactions.times do |i|
+          request = Appsignal::Transaction::GenericRequest.new(
+            :controller => 'HomeController',
+            :action     => 'show',
+            :params     => {:id => 1}
+          )
+          Appsignal::Transaction.create("transaction_#{i}", Appsignal::Transaction::HTTP_REQUEST, request)
+
+          Appsignal.instrument('process_action.action_controller') do
+            Appsignal.instrument_sql('sql.active_record', nil, 'SELECT `users`.* FROM `users` WHERE `users`.`id` = ?')
+            10.times do
+              Appsignal.instrument_sql('sql.active_record', nil, 'SELECT `todos`.* FROM `todos` WHERE `todos`.`id` = ?')
+            end
+
+            Appsignal.instrument('render_template.action_view', 'app/views/home/show.html.erb') do
+              5.times do
+                Appsignal.instrument('render_partial.action_view', 'app/views/home/_piece.html.erb') do
+                  3.times do
+                    Appsignal.instrument('cache.read')
+                  end
+                end
+              end
+            end
+          end
+
+          Appsignal::Transaction.complete_current!
+        end
+      end
+      thread.abort_on_exception = true
+      threads << thread
+    end
+
+    threads.each(&:join)
+    puts 'Finished'
+  end)
+
+  puts "Done, currently #{ObjectSpace.count_objects[:TOTAL] - total_objects} objects created"
+end

data/bin/appsignal

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require "appsignal/cli"
+
+begin
+  Appsignal::CLI.run
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end

data/ext/Rakefile

@@ -0,0 +1,27 @@
+require File.expand_path("../../lib/appsignal/version.rb", __FILE__)
+require File.expand_path("../base.rb", __FILE__)
+
+task :default do
+  begin
+    logger.info "Installing appsignal agent #{Appsignal::VERSION} for Ruby #{RUBY_VERSION} on #{RUBY_PLATFORM}"
+    write_agent_architecture
+    next unless check_architecture
+    arch_config = AGENT_CONFIG["triples"][ARCH]
+
+    unless File.exist?(ext_path("appsignal-agent")) &&
+        (
+          File.exist?(ext_path("libappsignal.dylib")) ||
+          File.exist?(ext_path("libappsignal.so"))
+        ) &&
+        File.exist?(ext_path("appsignal.h"))
+      archive = download_archive(arch_config, "dynamic")
+      next unless verify_archive(archive, arch_config, "dynamic")
+      unarchive(archive)
+    end
+  rescue => ex
+    installation_failed "Exception while installing: #{ex}"
+    ex.backtrace.each do |line|
+      logger.error line
+    end
+  end
+end

data/ext/agent.yml

@@ -0,0 +1,64 @@
+---
+version: 57a48f4
+triples:
+  x86_64-darwin:
+    static:
+      checksum: 4fa30287925bad17abb3e86784793e13399dd9390c0579ca94bd8f4ee7a832a3
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-darwin-all-static.tar.gz
+    dynamic:
+      checksum: 1380d4d7263b0fe2a546085efa64643289010b7dd21282c2900e81164a123e8d
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-darwin-all-dynamic.tar.gz
+  universal-darwin:
+    static:
+      checksum: 4fa30287925bad17abb3e86784793e13399dd9390c0579ca94bd8f4ee7a832a3
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-darwin-all-static.tar.gz
+    dynamic:
+      checksum: 1380d4d7263b0fe2a546085efa64643289010b7dd21282c2900e81164a123e8d
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-darwin-all-dynamic.tar.gz
+  i686-linux:
+    static:
+      checksum: 9a1e59dd42e5ddcd0af04c0cffb0aadeace05dfae46d00aec71e90490186cbfd
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-i686-linux-all-static.tar.gz
+    dynamic:
+      checksum: ef45877189d3ea4be568ec2fa64a0f04fc94783c42e53f6a55672576a2cfb150
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-i686-linux-all-dynamic.tar.gz
+  x86-linux:
+    static:
+      checksum: 9a1e59dd42e5ddcd0af04c0cffb0aadeace05dfae46d00aec71e90490186cbfd
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-i686-linux-all-static.tar.gz
+    dynamic:
+      checksum: ef45877189d3ea4be568ec2fa64a0f04fc94783c42e53f6a55672576a2cfb150
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-i686-linux-all-dynamic.tar.gz
+  i686-linux-musl:
+    static:
+      checksum: cfa14d6aa3ad419a1d87854dfb13a780b34e4ccbf3afbe6adc7704ef750fc414
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-i686-linux-musl-all-static.tar.gz
+  x86-linux-musl:
+    static:
+      checksum: cfa14d6aa3ad419a1d87854dfb13a780b34e4ccbf3afbe6adc7704ef750fc414
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-i686-linux-musl-all-static.tar.gz
+  x86_64-linux:
+    static:
+      checksum: 8a68e7da4710fc97be73210437c890897a84f37f6ae9095f36d61099e52f07dc
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-linux-all-static.tar.gz
+    dynamic:
+      checksum: 5b2806ae841a6052f55c0824370dad41a04ae0ad2025df87a54847cce81054c3
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-linux-all-dynamic.tar.gz
+  x86_64-linux-musl:
+    static:
+      checksum: ffc91182064c1f0dbd9d219816054903fcc28db977cdd74df15802c468a2f252
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-linux-musl-all-static.tar.gz
+  x86_64-freebsd:
+    static:
+      checksum: c1781a09ec4e4c9e2f08a60e662acd8790286ebad62c9d32712a7932d0852a10
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-freebsd-all-static.tar.gz
+    dynamic:
+      checksum: 0ce479051f5734b330d91811c51813d93e65758ecad97e5f6b9e86764480e7c2
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-freebsd-all-dynamic.tar.gz
+  amd64-freebsd:
+    static:
+      checksum: c1781a09ec4e4c9e2f08a60e662acd8790286ebad62c9d32712a7932d0852a10
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-freebsd-all-static.tar.gz
+    dynamic:
+      checksum: 0ce479051f5734b330d91811c51813d93e65758ecad97e5f6b9e86764480e7c2
+      download_url: https://appsignal-agent-releases.global.ssl.fastly.net/57a48f4/appsignal-x86_64-freebsd-all-dynamic.tar.gz

data/ext/appsignal_extension.c

@@ -0,0 +1,692 @@
+#include "ruby/ruby.h"
+#include "ruby/encoding.h"
+#include "appsignal.h"
+
+static inline appsignal_string_t make_appsignal_string(VALUE str) {
+  return (appsignal_string_t) {
+    .len = RSTRING_LEN(str),
+    .buf = RSTRING_PTR(str)
+  };
+}
+
+static inline VALUE make_ruby_string(appsignal_string_t string) {
+  VALUE str = rb_str_new(string.buf, string.len);
+  rb_enc_associate(str, rb_utf8_encoding());
+  return str;
+}
+
+VALUE Appsignal;
+VALUE Extension;
+VALUE Transaction;
+VALUE Data;
+
+static VALUE start(VALUE self) {
+  appsignal_start();
+
+  return Qnil;
+}
+
+static VALUE stop(VALUE self) {
+  appsignal_stop();
+
+  return Qnil;
+}
+
+static VALUE diagnose(VALUE self) {
+  return make_ruby_string(appsignal_diagnose());
+}
+
+static VALUE get_server_state(VALUE self, VALUE key) {
+  appsignal_string_t string;
+
+  Check_Type(key, T_STRING);
+
+  string = appsignal_get_server_state(make_appsignal_string(key));
+  if (string.len > 0) {
+    return make_ruby_string(string);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE start_transaction(VALUE self, VALUE transaction_id, VALUE namespace, VALUE gc_duration_ms) {
+  appsignal_transaction_t* transaction;
+
+  Check_Type(transaction_id, T_STRING);
+  Check_Type(namespace, T_STRING);
+  Check_Type(gc_duration_ms, T_FIXNUM);
+
+  transaction = appsignal_start_transaction(
+      make_appsignal_string(transaction_id),
+      make_appsignal_string(namespace),
+      NUM2LONG(gc_duration_ms)
+  );
+
+  if (transaction) {
+    return Data_Wrap_Struct(Transaction, NULL, appsignal_free_transaction, transaction);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE start_event(VALUE self, VALUE gc_duration_ms) {
+  appsignal_transaction_t* transaction;
+
+  Check_Type(gc_duration_ms, T_FIXNUM);
+
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  appsignal_start_event(transaction, NUM2LONG(gc_duration_ms));
+
+  return Qnil;
+}
+
+static VALUE finish_event(VALUE self, VALUE name, VALUE title, VALUE body, VALUE body_format, VALUE gc_duration_ms) {
+  appsignal_transaction_t* transaction;
+  appsignal_data_t* body_data;
+  int body_type;
+
+  Check_Type(name, T_STRING);
+  Check_Type(title, T_STRING);
+  Check_Type(body_format, T_FIXNUM);
+
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  body_type = TYPE(body);
+  if (body_type == T_STRING) {
+    appsignal_finish_event(
+        transaction,
+        make_appsignal_string(name),
+        make_appsignal_string(title),
+        make_appsignal_string(body),
+        FIX2INT(body_format),
+        FIX2LONG(gc_duration_ms)
+    );
+  } else if (body_type == RUBY_T_DATA) {
+    Data_Get_Struct(body, appsignal_data_t, body_data);
+    appsignal_finish_event_data(
+        transaction,
+        make_appsignal_string(name),
+        make_appsignal_string(title),
+        body_data,
+        FIX2INT(body_format),
+        FIX2LONG(gc_duration_ms)
+    );
+  } else {
+      rb_raise(rb_eTypeError, "body should be a String or Appsignal::Extension::Data");
+  }
+
+  return Qnil;
+}
+
+static VALUE record_event(VALUE self, VALUE name, VALUE title, VALUE body, VALUE body_format, VALUE duration, VALUE gc_duration_ms) {
+  appsignal_transaction_t* transaction;
+  appsignal_data_t* body_data;
+  int body_type;
+  int duration_type;
+
+  Check_Type(name, T_STRING);
+  Check_Type(title, T_STRING);
+  duration_type = TYPE(duration);
+  if (duration_type != T_FIXNUM && duration_type != T_BIGNUM) {
+      rb_raise(rb_eTypeError, "duration should be an Integer");
+  }
+  Check_Type(body_format, T_FIXNUM);
+
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  body_type = TYPE(body);
+  if (body_type == T_STRING) {
+    appsignal_record_event(
+        transaction,
+        make_appsignal_string(name),
+        make_appsignal_string(title),
+        make_appsignal_string(body),
+        FIX2INT(body_format),
+        NUM2LONG(duration),
+        NUM2LONG(gc_duration_ms)
+    );
+  } else if (body_type == RUBY_T_DATA) {
+    Data_Get_Struct(body, appsignal_data_t, body_data);
+    appsignal_record_event_data(
+        transaction,
+        make_appsignal_string(name),
+        make_appsignal_string(title),
+        body_data,
+        FIX2INT(body_format),
+        NUM2LONG(duration),
+        NUM2LONG(gc_duration_ms)
+    );
+  } else {
+      rb_raise(rb_eTypeError, "body should be a String or Appsignal::Extension::Data");
+  }
+
+  return Qnil;
+}
+
+static VALUE set_transaction_error(VALUE self, VALUE name, VALUE message, VALUE backtrace) {
+  appsignal_transaction_t* transaction;
+  appsignal_data_t* backtrace_data;
+
+  Check_Type(name, T_STRING);
+  Check_Type(message, T_STRING);
+  Check_Type(backtrace, RUBY_T_DATA);
+
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+  Data_Get_Struct(backtrace, appsignal_data_t, backtrace_data);
+
+  appsignal_set_transaction_error(
+      transaction,
+      make_appsignal_string(name),
+      make_appsignal_string(message),
+      backtrace_data
+  );
+  return Qnil;
+}
+
+static VALUE set_transaction_sample_data(VALUE self, VALUE key, VALUE payload) {
+  appsignal_transaction_t* transaction;
+  appsignal_data_t* payload_data;
+
+  Check_Type(key, T_STRING);
+  Check_Type(payload, RUBY_T_DATA);
+
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+  Data_Get_Struct(payload, appsignal_data_t, payload_data);
+
+  appsignal_set_transaction_sample_data(
+      transaction,
+      make_appsignal_string(key),
+      payload_data
+  );
+  return Qnil;
+}
+
+static VALUE set_transaction_action(VALUE self, VALUE action) {
+  appsignal_transaction_t* transaction;
+
+  Check_Type(action, T_STRING);
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  appsignal_set_transaction_action(
+      transaction,
+      make_appsignal_string(action)
+  );
+  return Qnil;
+}
+
+static VALUE set_transaction_namespace(VALUE self, VALUE namespace) {
+  appsignal_transaction_t* transaction;
+
+  Check_Type(namespace, T_STRING);
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  appsignal_set_transaction_namespace(
+      transaction,
+      make_appsignal_string(namespace)
+  );
+  return Qnil;
+}
+
+static VALUE set_transaction_queue_start(VALUE self, VALUE queue_start) {
+  appsignal_transaction_t* transaction;
+  int queue_start_type;
+
+  queue_start_type = TYPE(queue_start);
+  if (queue_start_type != T_FIXNUM && queue_start_type != T_BIGNUM) {
+      rb_raise(rb_eTypeError, "queue_start should be an Integer");
+  }
+
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  appsignal_set_transaction_queue_start(
+      transaction,
+      NUM2LONG(queue_start)
+  );
+  return Qnil;
+}
+
+static VALUE set_transaction_metadata(VALUE self, VALUE key, VALUE value) {
+  appsignal_transaction_t* transaction;
+
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_STRING);
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  appsignal_set_transaction_metadata(
+      transaction,
+      make_appsignal_string(key),
+      make_appsignal_string(value)
+  );
+  return Qnil;
+}
+
+static VALUE finish_transaction(VALUE self, VALUE gc_duration_ms) {
+  appsignal_transaction_t* transaction;
+  int sample;
+
+  Check_Type(gc_duration_ms, T_FIXNUM);
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  sample = appsignal_finish_transaction(transaction, NUM2LONG(gc_duration_ms));
+  return sample == 1 ? Qtrue : Qfalse;
+}
+
+static VALUE complete_transaction(VALUE self) {
+  appsignal_transaction_t* transaction;
+
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  appsignal_complete_transaction(transaction);
+  return Qnil;
+}
+
+static VALUE transaction_to_json(VALUE self) {
+  appsignal_transaction_t* transaction;
+  appsignal_string_t json;
+
+  Data_Get_Struct(self, appsignal_transaction_t, transaction);
+
+  json = appsignal_transaction_to_json(transaction);
+
+  if (json.len == 0) {
+    return Qnil;
+  } else {
+    return make_ruby_string(json);
+  }
+}
+
+static VALUE data_map_new(VALUE self) {
+  appsignal_data_t* data;
+
+  data = appsignal_data_map_new();
+
+  if (data) {
+    return Data_Wrap_Struct(Data, NULL, appsignal_free_data, data);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE data_array_new(VALUE self) {
+  appsignal_data_t* data;
+
+  data = appsignal_data_array_new();
+
+  if (data) {
+    return Data_Wrap_Struct(Data, NULL, appsignal_free_data, data);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE data_set_string(VALUE self, VALUE key, VALUE value) {
+  appsignal_data_t* data;
+
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_STRING);
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_map_set_string(
+    data,
+    make_appsignal_string(key),
+    make_appsignal_string(value)
+  );
+
+  return Qnil;
+}
+
+static VALUE data_set_integer(VALUE self, VALUE key, VALUE value) {
+  appsignal_data_t* data;
+  VALUE value_type = TYPE(value);
+
+  Check_Type(key, T_STRING);
+  if (value_type != T_FIXNUM && value_type != T_BIGNUM) {
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected Integer)", rb_obj_classname(value));
+  }
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_map_set_integer(
+    data,
+    make_appsignal_string(key),
+    NUM2LONG(value)
+  );
+
+  return Qnil;
+}
+
+static VALUE data_set_float(VALUE self, VALUE key, VALUE value) {
+  appsignal_data_t* data;
+
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_FLOAT);
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_map_set_float(
+    data,
+    make_appsignal_string(key),
+    NUM2DBL(value)
+  );
+
+  return Qnil;
+}
+
+static VALUE data_set_boolean(VALUE self, VALUE key, VALUE value) {
+  appsignal_data_t* data;
+
+  Check_Type(key, T_STRING);
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_map_set_boolean(
+    data,
+    make_appsignal_string(key),
+    RTEST(value)
+  );
+
+  return Qnil;
+}
+
+static VALUE data_set_nil(VALUE self, VALUE key) {
+  appsignal_data_t* data;
+
+  Check_Type(key, T_STRING);
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_map_set_null(
+    data,
+    make_appsignal_string(key)
+  );
+
+  return Qnil;
+}
+
+static VALUE data_set_data(VALUE self, VALUE key, VALUE value) {
+  appsignal_data_t* data;
+  appsignal_data_t* value_data;
+
+  Check_Type(key, T_STRING);
+  Check_Type(value, RUBY_T_DATA);
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+  Data_Get_Struct(value, appsignal_data_t, value_data);
+
+  appsignal_data_map_set_data(
+    data,
+    make_appsignal_string(key),
+    value_data
+  );
+
+  return Qnil;
+}
+
+static VALUE data_append_string(VALUE self, VALUE value) {
+  appsignal_data_t* data;
+
+  Check_Type(value, T_STRING);
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_array_append_string(
+    data,
+    make_appsignal_string(value)
+  );
+
+  return Qnil;
+}
+
+static VALUE data_append_integer(VALUE self, VALUE value) {
+  appsignal_data_t* data;
+  VALUE value_type = TYPE(value);
+
+  if (value_type != T_FIXNUM && value_type != T_BIGNUM) {
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected Integer)", rb_obj_classname(value));
+  }
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_array_append_integer(
+    data,
+    NUM2LONG(value)
+ );
+
+  return Qnil;
+}
+
+static VALUE data_append_float(VALUE self, VALUE value) {
+  appsignal_data_t* data;
+
+  Check_Type(value, T_FLOAT);
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_array_append_float(
+    data,
+    NUM2DBL(value)
+ );
+
+  return Qnil;
+}
+
+static VALUE data_append_boolean(VALUE self, VALUE value) {
+  appsignal_data_t* data;
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_array_append_boolean(
+    data,
+    RTEST(value)
+ );
+
+  return Qnil;
+}
+
+static VALUE data_append_nil(VALUE self, VALUE value) {
+  appsignal_data_t* data;
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  appsignal_data_array_append_null(data);
+
+  return Qnil;
+}
+
+static VALUE data_append_data(VALUE self, VALUE value) {
+  appsignal_data_t* data;
+  appsignal_data_t* value_data;
+
+  Check_Type(value, RUBY_T_DATA);
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+  Data_Get_Struct(value, appsignal_data_t, value_data);
+
+  appsignal_data_array_append_data(
+    data,
+    value_data
+  );
+
+  return Qnil;
+}
+
+static VALUE data_equal(VALUE self, VALUE other) {
+  appsignal_data_t* data;
+  appsignal_data_t* other_data;
+
+  if (TYPE(other) != RUBY_T_DATA) {
+    return Qfalse;
+  }
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+  Data_Get_Struct(other, appsignal_data_t, other_data);
+
+  if (appsignal_data_equal(data, other_data) == 1) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE data_to_s(VALUE self) {
+  appsignal_data_t* data;
+  appsignal_string_t json;
+
+  Data_Get_Struct(self, appsignal_data_t, data);
+
+  json = appsignal_data_to_json(data);
+
+  if (json.len == 0) {
+    return Qnil;
+  } else {
+    return make_ruby_string(json);
+  }
+}
+
+static VALUE set_gauge(VALUE self, VALUE key, VALUE value) {
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_FLOAT);
+
+  appsignal_set_gauge(
+      make_appsignal_string(key),
+      NUM2DBL(value)
+  );
+  return Qnil;
+}
+
+static VALUE set_host_gauge(VALUE self, VALUE key, VALUE value) {
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_FLOAT);
+
+  appsignal_set_host_gauge(
+      make_appsignal_string(key),
+      NUM2DBL(value)
+  );
+  return Qnil;
+}
+
+static VALUE set_process_gauge(VALUE self, VALUE key, VALUE value) {
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_FLOAT);
+
+  appsignal_set_process_gauge(
+      make_appsignal_string(key),
+      NUM2DBL(value)
+  );
+  return Qnil;
+}
+
+static VALUE increment_counter(VALUE self, VALUE key, VALUE count) {
+  Check_Type(key, T_STRING);
+  Check_Type(count, T_FIXNUM);
+
+  appsignal_increment_counter(
+      make_appsignal_string(key),
+      FIX2INT(count)
+  );
+  return Qnil;
+}
+
+static VALUE add_distribution_value(VALUE self, VALUE key, VALUE value) {
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_FLOAT);
+
+  appsignal_add_distribution_value(
+      make_appsignal_string(key),
+      NUM2DBL(value)
+  );
+  return Qnil;
+}
+
+static void track_allocation(rb_event_flag_t flag, VALUE arg1, VALUE arg2, ID arg3, VALUE arg4) {
+  appsignal_track_allocation();
+}
+
+static VALUE install_allocation_event_hook() {
+  // This event hook is only available on Ruby 2.1 and 2.2
+  #if defined(RUBY_INTERNAL_EVENT_NEWOBJ)
+  rb_add_event_hook(
+      track_allocation,
+      RUBY_INTERNAL_EVENT_NEWOBJ,
+      Qnil
+  );
+  #endif
+
+  return Qnil;
+}
+
+static VALUE running_in_container() {
+  return appsignal_running_in_container() == 1 ? Qtrue : Qfalse;
+}
+
+void Init_appsignal_extension(void) {
+  Appsignal = rb_define_module("Appsignal");
+  Extension = rb_define_class_under(Appsignal, "Extension", rb_cObject);
+  Transaction = rb_define_class_under(Extension, "Transaction", rb_cObject);
+  Data = rb_define_class_under(Extension, "Data", rb_cObject);
+
+  // Starting and stopping
+  rb_define_singleton_method(Extension, "start",    start,    0);
+  rb_define_singleton_method(Extension, "stop",     stop,     0);
+  // Diagnostics
+  rb_define_singleton_method(Extension, "diagnose", diagnose, 0);
+
+  // Server state
+  rb_define_singleton_method(Extension, "get_server_state", get_server_state, 1);
+
+  // Start transaction
+  rb_define_singleton_method(Extension, "start_transaction", start_transaction, 3);
+
+  // Transaction instance methods
+  rb_define_method(Transaction, "start_event",     start_event,                 1);
+  rb_define_method(Transaction, "finish_event",    finish_event,                5);
+  rb_define_method(Transaction, "record_event",    record_event,                6);
+  rb_define_method(Transaction, "set_error",       set_transaction_error,       3);
+  rb_define_method(Transaction, "set_sample_data", set_transaction_sample_data, 2);
+  rb_define_method(Transaction, "set_action",      set_transaction_action,      1);
+  rb_define_method(Transaction, "set_namespace",   set_transaction_namespace,   1);
+  rb_define_method(Transaction, "set_queue_start", set_transaction_queue_start, 1);
+  rb_define_method(Transaction, "set_metadata",    set_transaction_metadata,    2);
+  rb_define_method(Transaction, "finish",          finish_transaction,          1);
+  rb_define_method(Transaction, "complete",        complete_transaction,        0);
+  rb_define_method(Transaction, "to_json",         transaction_to_json,         0);
+
+  // Create a data map or array
+  rb_define_singleton_method(Extension, "data_map_new", data_map_new, 0);
+  rb_define_singleton_method(Extension, "data_array_new", data_array_new, 0);
+
+  // Add content to a data map
+  rb_define_method(Data, "set_string",  data_set_string,  2);
+  rb_define_method(Data, "set_integer", data_set_integer, 2);
+  rb_define_method(Data, "set_float",   data_set_float,   2);
+  rb_define_method(Data, "set_boolean", data_set_boolean, 2);
+  rb_define_method(Data, "set_nil",     data_set_nil,     1);
+  rb_define_method(Data, "set_data",    data_set_data,    2);
+
+  // Add content to a data array
+  rb_define_method(Data, "append_string",  data_append_string,  1);
+  rb_define_method(Data, "append_integer", data_append_integer, 1);
+  rb_define_method(Data, "append_float",   data_append_float,   1);
+  rb_define_method(Data, "append_boolean", data_append_boolean, 1);
+  rb_define_method(Data, "append_nil",     data_append_nil,     0);
+  rb_define_method(Data, "append_data",    data_append_data,    1);
+
+  // Data equality
+  rb_define_method(Data, "==", data_equal, 1);
+
+  // Get JSON content of a data
+  rb_define_method(Data, "to_s", data_to_s, 0);
+
+  // Event hook installation
+  rb_define_singleton_method(Extension, "install_allocation_event_hook", install_allocation_event_hook, 0);
+  rb_define_singleton_method(Extension, "running_in_container?", running_in_container, 0);
+
+  // Metrics
+  rb_define_singleton_method(Extension, "set_gauge",              set_gauge,              2);
+  rb_define_singleton_method(Extension, "set_host_gauge",         set_host_gauge,         2);
+  rb_define_singleton_method(Extension, "set_process_gauge",      set_process_gauge,      2);
+  rb_define_singleton_method(Extension, "increment_counter",      increment_counter,      2);
+  rb_define_singleton_method(Extension, "add_distribution_value", add_distribution_value, 2);
+}