rrtrace 0.1.0 → 0.2.0

data/ext/rrtrace/rrtrace.c

@@ -1,7 +1,7 @@
 #include "rrtrace.h"
 #include "rrtrace_event_ringbuffer.h"
 
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__MINGW32__) || defined(__MINGW64__)
 #include "process_manager_windows.h"
 #include "shared_memory_windows.h"
 #else
@@ -20,10 +20,22 @@ typedef struct {
 } ThreadData;
 
 typedef struct {
+  shared_memory_handle shared_memory;
   RRTraceEventRingBuffer *event_ringbuffer;
   process_id visualizer_process_id;
+  rb_internal_thread_event_hook_t *thread_start_hook;
+  rb_internal_thread_event_hook_t *thread_ready_hook;
+  rb_internal_thread_event_hook_t *thread_suspended_hook;
+  rb_internal_thread_event_hook_t *thread_resume_hook;
+  rb_internal_thread_event_hook_t *thread_exit_hook;
+  VALUE trace_call;
+  VALUE trace_return;
+  VALUE trace_gc_start;
+  VALUE trace_gc_end;
   rb_internal_thread_specific_key_t thread_data_key;
   atomic_uint_fast32_t next_thread_id;
+  atomic_flag event_ringbuffer_lock;
+  int started;
 #ifdef RRTRACE_WRITE_DEBUG_LOG
   FILE *log;
 #endif
@@ -31,12 +43,15 @@ typedef struct {
 
 static inline void push_event(TraceContext *context, RRTraceEvent event) {
   if (context->event_ringbuffer == NULL) return;
+  while (atomic_flag_test_and_set_explicit(&context->event_ringbuffer_lock, memory_order_acquire)) {
+  }
   while (!rrtrace_event_ringbuffer_push(context->event_ringbuffer, event)) {
     if (!is_process_running(context->visualizer_process_id)) {
       context->event_ringbuffer = NULL;
       break;
     }
   }
+  atomic_flag_clear_explicit(&context->event_ringbuffer_lock, memory_order_release);
 }
 
 static uint32_t get_thread_id(TraceContext *context, VALUE thread) {
@@ -93,80 +108,137 @@ static void tracepoint_gc_end_handler(VALUE tpval, void *data) {
 
 static void thread_start_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
   TraceContext *context = (TraceContext *)data;
-  push_event(context, event_thread_start(get_thread_id(context, event_data->thread)));
+  uint32_t thread_id = get_thread_id(context, event_data->thread);
+  push_event(context, event_thread_start(thread_id));
 #ifdef RRTRACE_WRITE_DEBUG_LOG
-  fprintf(context->log, "THREAD START\n");
+  fprintf(context->log, "THREAD %02d START\n", thread_id);
   fflush(context->log);
 #endif
 }
 
 static void thread_ready_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
   TraceContext *context = (TraceContext *)data;
-  push_event(context, event_thread_ready(get_thread_id(context, event_data->thread)));
+  uint32_t thread_id = get_thread_id(context, event_data->thread);
+  push_event(context, event_thread_ready(thread_id));
 #ifdef RRTRACE_WRITE_DEBUG_LOG
-  fprintf(context->log, "THREAD READY\n");
+  fprintf(context->log, "THREAD %02d READY\n", thread_id);
   fflush(context->log);
 #endif
 }
 
 static void thread_suspended_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
   TraceContext *context = (TraceContext *)data;
-  push_event(context, event_thread_suspended(get_thread_id(context, event_data->thread)));
+  uint32_t thread_id = get_thread_id(context, event_data->thread);
+  push_event(context, event_thread_suspended(thread_id));
 #ifdef RRTRACE_WRITE_DEBUG_LOG
-  fprintf(context->log, "THREAD SUSPENDED\n");
+  fprintf(context->log, "THREAD %02d SUSPENDED\n", thread_id);
   fflush(context->log);
 #endif
 }
 
 static void thread_resume_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
   TraceContext *context = (TraceContext *)data;
-  push_event(context, event_thread_resume(get_thread_id(context, event_data->thread)));
+  uint32_t thread_id = get_thread_id(context, event_data->thread);
+  push_event(context, event_thread_resume(thread_id));
 #ifdef RRTRACE_WRITE_DEBUG_LOG
-  fprintf(context->log, "THREAD RESUME\n");
+  fprintf(context->log, "THREAD %02d RESUME\n", thread_id);
   fflush(context->log);
 #endif
 }
 
 static void thread_exit_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
   TraceContext *context = (TraceContext *)data;
-  push_event(context, event_thread_exit(get_thread_id(context, event_data->thread)));
+  uint32_t thread_id = get_thread_id(context, event_data->thread);
+  push_event(context, event_thread_exit(thread_id));
 #ifdef RRTRACE_WRITE_DEBUG_LOG
-  fprintf(context->log, "THREAD EXIT\n");
+  fprintf(context->log, "THREAD %02d EXIT\n", thread_id);
   fflush(context->log);
 #endif
 }
 
-RUBY_FUNC_EXPORTED void
-Init_rrtrace(void)
-{
-  TraceContext *context = malloc(sizeof(TraceContext));
-  context->thread_data_key = rb_internal_thread_specific_key_create();
-  atomic_init(&context->next_thread_id, 1);
-#ifdef RRTRACE_WRITE_DEBUG_LOG
-  context->log = fopen("rrtrace.log", "w");
-#endif
+static TraceContext trace_context;
+
+static void unregister_tracepoint(VALUE *tracepoint) {
+  if (NIL_P(*tracepoint)) return;
+
+  rb_tracepoint_disable(*tracepoint);
+  rb_gc_unregister_address(tracepoint);
+  *tracepoint = Qnil;
+}
+
+static void remove_thread_hook(rb_internal_thread_event_hook_t **hook) {
+  if (*hook == NULL) return;
+
+  rb_internal_thread_remove_event_hook(*hook);
+  *hook = NULL;
+}
+
+static void cleanup_context(TraceContext *context) {
+  unregister_tracepoint(&context->trace_call);
+  unregister_tracepoint(&context->trace_return);
+  unregister_tracepoint(&context->trace_gc_start);
+  unregister_tracepoint(&context->trace_gc_end);
+
+  remove_thread_hook(&context->thread_start_hook);
+  remove_thread_hook(&context->thread_ready_hook);
+  remove_thread_hook(&context->thread_suspended_hook);
+  remove_thread_hook(&context->thread_resume_hook);
+  remove_thread_hook(&context->thread_exit_hook);
+
+  context->event_ringbuffer = NULL;
+  close_shared_memory(&context->shared_memory);
+
+  if (context->visualizer_process_id != invalid_process_id()) {
+    terminate_process(context->visualizer_process_id);
+    close_process(context->visualizer_process_id);
+    context->visualizer_process_id = invalid_process_id();
+  }
+
+  context->started = 0;
+}
+
+static VALUE rrtrace_native_started_p(VALUE self) {
+  return trace_context.started ? Qtrue : Qfalse;
+}
+
+static VALUE rrtrace_native_stop(VALUE self) {
+  if (!trace_context.started) return Qfalse;
+
+  cleanup_context(&trace_context);
+  return Qtrue;
+}
+
+static VALUE rrtrace_native_start(VALUE self, VALUE visualizer) {
+  TraceContext *context = &trace_context;
+  VALUE visualizer_path = rb_str_dup(StringValue(visualizer));
+  char *visualizer_path_cstr = StringValueCStr(visualizer_path);
+
+  if (context->started) return Qfalse;
+
+  atomic_store_explicit(&context->next_thread_id, 1, memory_order_relaxed);
 
   char shm_name[64];
   generate_shared_memory_name(shm_name, sizeof(shm_name));
-  RRTraceEventRingBuffer *ringbuffer = open_shared_memory(shm_name, sizeof(RRTraceEventRingBuffer));
-  if (ringbuffer == NULL) {
+  context->shared_memory = open_shared_memory(shm_name, sizeof(RRTraceEventRingBuffer));
+  if (!shared_memory_opened(context->shared_memory)) {
     rb_raise(rb_eRuntimeError, "Failed to create shared memory for rrtrace");
-    return;
+    return Qfalse;
   }
+
+  RRTraceEventRingBuffer *ringbuffer = shared_memory_ptr(&context->shared_memory);
   rrtrace_event_ringbuffer_init(ringbuffer);
   context->event_ringbuffer = ringbuffer;
 
-  VALUE mMyGem = rb_const_get(rb_cObject, rb_intern("Rrtrace"));
-  VALUE visualizer = rb_funcall(mMyGem, rb_intern("visualizer_path"), 0);
-  char *visualizer_path = rb_string_value_cstr(&visualizer);
 #ifdef RRTRACE_WRITE_DEBUG_LOG
-  fprintf(context->log, "Visualizer: %s\n", visualizer_path);
+  fprintf(context->log, "Visualizer: %s\n", visualizer_path_cstr);
   fprintf(context->log, "Shared Memory: %s\n", shm_name);
 #endif
-  process_id pid = spawn_process(visualizer_path, (char * const[]){visualizer_path, shm_name, NULL});
-  if (pid == 0) {
+  init_base_timestamp();
+  process_id pid = spawn_process(visualizer_path_cstr, (char * const[]){visualizer_path_cstr, shm_name, NULL});
+  if (pid == invalid_process_id()) {
+    cleanup_context(context);
     rb_raise(rb_eRuntimeError, "Failed to spawn visualizer process");
-    return;
+    return Qfalse;
   }
   context->visualizer_process_id = pid;
 
@@ -175,18 +247,55 @@ Init_rrtrace(void)
   VALUE thread = rb_thread_current();
   rb_internal_thread_specific_set(thread, context->thread_data_key, main_thread_data);
 
-  VALUE trace_call = rb_tracepoint_new(RUBY_Qnil, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL, tracepoint_call_handler, context);
-  VALUE trace_return = rb_tracepoint_new(RUBY_Qnil, RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN, tracepoint_return_handler, context);
-  VALUE trace_gc_start = rb_tracepoint_new(RUBY_Qnil, RUBY_INTERNAL_EVENT_GC_ENTER, tracepoint_gc_start_handler, context);
-  VALUE trace_gc_end = rb_tracepoint_new(RUBY_Qnil, RUBY_INTERNAL_EVENT_GC_EXIT, tracepoint_gc_end_handler, context);
-  rb_internal_thread_add_event_hook(thread_start_handler, RUBY_INTERNAL_THREAD_EVENT_STARTED, context);
-  rb_internal_thread_add_event_hook(thread_ready_handler, RUBY_INTERNAL_THREAD_EVENT_READY, context);
-  rb_internal_thread_add_event_hook(thread_suspended_handler, RUBY_INTERNAL_THREAD_EVENT_SUSPENDED, context);
-  rb_internal_thread_add_event_hook(thread_resume_handler, RUBY_INTERNAL_THREAD_EVENT_RESUMED, context);
-  rb_internal_thread_add_event_hook(thread_exit_handler, RUBY_INTERNAL_THREAD_EVENT_EXITED, context);
-
-  rb_tracepoint_enable(trace_call);
-  rb_tracepoint_enable(trace_return);
-  rb_tracepoint_enable(trace_gc_start);
-  rb_tracepoint_enable(trace_gc_end);
+  context->trace_call = rb_tracepoint_new(RUBY_Qnil, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL, tracepoint_call_handler, context);
+  rb_gc_register_address(&context->trace_call);
+  context->trace_return = rb_tracepoint_new(RUBY_Qnil, RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN, tracepoint_return_handler, context);
+  rb_gc_register_address(&context->trace_return);
+  context->trace_gc_start = rb_tracepoint_new(RUBY_Qnil, RUBY_INTERNAL_EVENT_GC_ENTER, tracepoint_gc_start_handler, context);
+  rb_gc_register_address(&context->trace_gc_start);
+  context->trace_gc_end = rb_tracepoint_new(RUBY_Qnil, RUBY_INTERNAL_EVENT_GC_EXIT, tracepoint_gc_end_handler, context);
+  rb_gc_register_address(&context->trace_gc_end);
+  context->thread_start_hook = rb_internal_thread_add_event_hook(thread_start_handler, RUBY_INTERNAL_THREAD_EVENT_STARTED, context);
+  context->thread_ready_hook = rb_internal_thread_add_event_hook(thread_ready_handler, RUBY_INTERNAL_THREAD_EVENT_READY, context);
+  context->thread_suspended_hook = rb_internal_thread_add_event_hook(thread_suspended_handler, RUBY_INTERNAL_THREAD_EVENT_SUSPENDED, context);
+  context->thread_resume_hook = rb_internal_thread_add_event_hook(thread_resume_handler, RUBY_INTERNAL_THREAD_EVENT_RESUMED, context);
+  context->thread_exit_hook = rb_internal_thread_add_event_hook(thread_exit_handler, RUBY_INTERNAL_THREAD_EVENT_EXITED, context);
+
+  rb_tracepoint_enable(context->trace_call);
+  rb_tracepoint_enable(context->trace_return);
+  rb_tracepoint_enable(context->trace_gc_start);
+  rb_tracepoint_enable(context->trace_gc_end);
+
+  context->started = 1;
+  return Qtrue;
+}
+
+RUBY_FUNC_EXPORTED void
+Init_rrtrace(void)
+{
+  TraceContext *context = &trace_context;
+  context->shared_memory = invalid_shared_memory_handle();
+  context->event_ringbuffer = NULL;
+  context->visualizer_process_id = invalid_process_id();
+  context->thread_start_hook = NULL;
+  context->thread_ready_hook = NULL;
+  context->thread_suspended_hook = NULL;
+  context->thread_resume_hook = NULL;
+  context->thread_exit_hook = NULL;
+  context->trace_call = Qnil;
+  context->trace_return = Qnil;
+  context->trace_gc_start = Qnil;
+  context->trace_gc_end = Qnil;
+  context->thread_data_key = rb_internal_thread_specific_key_create();
+  atomic_init(&context->next_thread_id, 1);
+  atomic_flag_clear(&context->event_ringbuffer_lock);
+  context->started = 0;
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  context->log = fopen("rrtrace.log", "w");
+#endif
+
+  VALUE mRrtrace = rb_const_get(rb_cObject, rb_intern("Rrtrace"));
+  rb_define_singleton_method(mRrtrace, "native_start", rrtrace_native_start, 1);
+  rb_define_singleton_method(mRrtrace, "native_stop", rrtrace_native_stop, 0);
+  rb_define_singleton_method(mRrtrace, "native_started?", rrtrace_native_started_p, 0);
 }

data/ext/rrtrace/rrtrace_event.h

@@ -1,10 +1,15 @@
 #ifndef RRTRACE_EVENT_H
 #define RRTRACE_EVENT_H
 
-#include <time.h>
 #include <stdatomic.h>
 #include <stdint.h>
 
+#if defined(_WIN32) || defined(__MINGW32__) || defined(__MINGW64__)
+#include "time_windows.h"
+#else
+#include "time_posix.h"
+#endif
+
 #define EVENT_TYPE_CALL             0x0000000000000000ull
 #define EVENT_TYPE_RETURN           0x1000000000000000ull
 #define EVENT_TYPE_GC_START         0x2000000000000000ull
@@ -22,20 +27,6 @@ typedef struct {
     uint64_t data;
 } RRTraceEvent;
 
-static inline uint64_t now(void) {
-    struct timespec ts;
-    timespec_get(&ts, TIME_UTC);
-    uint64_t timestamp = (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec;
-
-    static atomic_uint_fast64_t base_timestamp = 0;
-    uint64_t expected = 0;
-    if (atomic_compare_exchange_strong_explicit(&base_timestamp, &expected, timestamp, memory_order_relaxed, memory_order_relaxed)) {
-        return 0;
-    } else {
-        return timestamp - expected;
-    }
-}
-
 static inline RRTraceEvent event_call(uint64_t method_id) {
     RRTraceEvent event;
     event.timestamp_and_event_type = now() | EVENT_TYPE_CALL;

data/ext/rrtrace/rrtrace_event_ringbuffer.h

@@ -8,11 +8,11 @@
 
 typedef struct {
     RRTraceEvent buffer[SIZE];
-    alignas(64) struct {
+    alignas(128) struct {
         atomic_uint_fast64_t write_index;
         uint64_t read_index_cache;
     } writer;
-    alignas(64) struct {
+    alignas(128) struct {
         atomic_uint_fast64_t read_index;
         uint64_t write_index_cache;
     } reader;

data/ext/rrtrace/shared_memory_posix.h

@@ -7,6 +7,14 @@
 #include <unistd.h>
 #include <time.h>
 #include <stdio.h>
+#include <string.h>
+
+typedef struct {
+    int fd;
+    void *ptr;
+    size_t size;
+    char name[64];
+} shared_memory_handle;
 
 static inline void generate_shared_memory_name(char *buffer, size_t size) {
     struct timespec ts;
@@ -14,13 +22,57 @@ static inline void generate_shared_memory_name(char *buffer, size_t size) {
     snprintf(buffer, size, "/rrtrace_shm_%d_%d", getpid(), (int)ts.tv_nsec);
 }
 
-static inline void* open_shared_memory(const char *name, int size) {
+static inline shared_memory_handle invalid_shared_memory_handle(void) {
+    shared_memory_handle shm;
+    shm.fd = -1;
+    shm.ptr = NULL;
+    shm.size = 0;
+    shm.name[0] = '\0';
+    return shm;
+}
+
+static inline shared_memory_handle open_shared_memory(const char *name, int size) {
     int fd = shm_open(name, O_CREAT | O_RDWR, 0666);
-    if (fd == -1) return NULL;
-    if (ftruncate(fd, size) == -1) return NULL;
+    if (fd == -1) return invalid_shared_memory_handle();
+    if (ftruncate(fd, size) == -1) {
+        close(fd);
+        return invalid_shared_memory_handle();
+    }
     void *ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-    if (ptr == MAP_FAILED) return NULL;
-    return ptr;
+    if (ptr == MAP_FAILED) {
+        close(fd);
+        return invalid_shared_memory_handle();
+    }
+
+    shared_memory_handle shm;
+    shm.fd = fd;
+    shm.ptr = ptr;
+    shm.size = size;
+    snprintf(shm.name, sizeof(shm.name), "%s", name);
+    return shm;
+}
+
+static inline int shared_memory_opened(shared_memory_handle shm) {
+    return shm.ptr != NULL;
+}
+
+static inline void *shared_memory_ptr(shared_memory_handle *shm) {
+    return shm->ptr;
+}
+
+static inline void close_shared_memory(shared_memory_handle *shm) {
+    if (shm->ptr != NULL) {
+        munmap(shm->ptr, shm->size);
+        shm->ptr = NULL;
+    }
+    if (shm->fd != -1) {
+        close(shm->fd);
+        shm->fd = -1;
+    }
+    if (shm->name[0] != '\0') {
+        shm_unlink(shm->name);
+        shm->name[0] = '\0';
+    }
 }
 
 #endif /* SHARED_MEMORY_POSIX_H */

data/ext/rrtrace/shared_memory_windows.h

@@ -4,11 +4,21 @@
 #include <windows.h>
 #include <stdio.h>
 
+typedef struct {
+    HANDLE handle;
+    void *ptr;
+} shared_memory_handle;
+
 static inline void generate_shared_memory_name(char *buffer, size_t size) {
     snprintf(buffer, size, "Local\\rrtrace_shm_%lu_%lu", GetCurrentProcessId(), GetTickCount());
 }
 
-static inline void* open_shared_memory(const char *name, int size) {
+static inline shared_memory_handle invalid_shared_memory_handle(void) {
+    shared_memory_handle shm = {0};
+    return shm;
+}
+
+static inline shared_memory_handle open_shared_memory(const char *name, int size) {
     HANDLE hMapFile = CreateFileMappingA(
         INVALID_HANDLE_VALUE,
         NULL,
@@ -18,7 +28,7 @@ static inline void* open_shared_memory(const char *name, int size) {
         name);
 
     if (hMapFile == NULL) {
-        return NULL;
+        return invalid_shared_memory_handle();
     }
 
     void *ptr = MapViewOfFile(
@@ -28,7 +38,32 @@ static inline void* open_shared_memory(const char *name, int size) {
         0,
         size);
 
-    return ptr;
+    if (ptr == NULL) {
+        CloseHandle(hMapFile);
+        return invalid_shared_memory_handle();
+    }
+
+    shared_memory_handle shm = {hMapFile, ptr};
+    return shm;
+}
+
+static inline int shared_memory_opened(shared_memory_handle shm) {
+    return shm.ptr != NULL;
+}
+
+static inline void *shared_memory_ptr(shared_memory_handle *shm) {
+    return shm->ptr;
+}
+
+static inline void close_shared_memory(shared_memory_handle *shm) {
+    if (shm->ptr != NULL) {
+        UnmapViewOfFile(shm->ptr);
+        shm->ptr = NULL;
+    }
+    if (shm->handle != NULL) {
+        CloseHandle(shm->handle);
+        shm->handle = NULL;
+    }
 }
 
 #endif /* SHARED_MEMORY_WIN_H */

data/ext/rrtrace/time_posix.h

@@ -0,0 +1,29 @@
+#ifndef RRTRACE_TIME_POSIX_H
+#define RRTRACE_TIME_POSIX_H
+
+#include <stdint.h>
+#include <time.h>
+
+static struct timespec rrtrace_base_timestamp = {0};
+
+static inline void init_base_timestamp(void) {
+    clock_gettime(CLOCK_MONOTONIC, &rrtrace_base_timestamp);
+}
+
+static inline uint64_t now(void) {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+
+    uint64_t seconds = (uint64_t)(ts.tv_sec - rrtrace_base_timestamp.tv_sec);
+    uint64_t nanoseconds;
+    if (ts.tv_nsec >= rrtrace_base_timestamp.tv_nsec) {
+        nanoseconds = (uint64_t)(ts.tv_nsec - rrtrace_base_timestamp.tv_nsec);
+    } else {
+        seconds -= 1;
+        nanoseconds = (uint64_t)ts.tv_nsec + 1000000000ull - (uint64_t)rrtrace_base_timestamp.tv_nsec;
+    }
+
+    return seconds * 1000000000ull + nanoseconds;
+}
+
+#endif /* RRTRACE_TIME_POSIX_H */

data/ext/rrtrace/time_windows.h

@@ -0,0 +1,33 @@
+#ifndef RRTRACE_TIME_WINDOWS_H
+#define RRTRACE_TIME_WINDOWS_H
+
+#include <stdint.h>
+#include <windows.h>
+
+static LARGE_INTEGER rrtrace_base_counter = {0};
+static LARGE_INTEGER rrtrace_counter_frequency = {0};
+
+static inline uint64_t rrtrace_counter_to_ns(uint64_t counter) {
+    uint64_t frequency = (uint64_t)rrtrace_counter_frequency.QuadPart;
+    uint64_t seconds = counter / frequency;
+    uint64_t remainder = counter % frequency;
+    return seconds * 1000000000ull + (remainder * 1000000000ull) / frequency;
+}
+
+static inline void init_base_timestamp(void) {
+    if (!QueryPerformanceFrequency(&rrtrace_counter_frequency) || rrtrace_counter_frequency.QuadPart <= 0) {
+        rrtrace_counter_frequency.QuadPart = 1;
+    }
+    if (!QueryPerformanceCounter(&rrtrace_base_counter)) {
+        rrtrace_base_counter.QuadPart = 0;
+    }
+}
+
+static inline uint64_t now(void) {
+    LARGE_INTEGER counter;
+    if (!QueryPerformanceCounter(&counter)) return 0;
+
+    return rrtrace_counter_to_ns((uint64_t)(counter.QuadPart - rrtrace_base_counter.QuadPart));
+}
+
+#endif /* RRTRACE_TIME_WINDOWS_H */

data/lib/rrtrace/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "rrtrace"
+
+Rrtrace.start

data/lib/rrtrace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rrtrace
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/rrtrace.rb

@@ -1,12 +1,40 @@
 # frozen_string_literal: true
 
+require "rbconfig"
+
 require_relative "rrtrace/version"
 
 module Rrtrace
-  def self.visualizer_path
-    exe = "rrtrace#{RbConfig::CONFIG["EXEEXT"]}"
-    File.expand_path("../libexec/#{exe}", __dir__)
+  class << self
+    def visualizer_path
+      @visualizer_path ||= default_visualizer_path
+    end
+
+    def start
+      native_start(visualizer_path)
+    end
+
+    def stop
+      native_stop
+    end
+
+    def started?
+      native_started?
+    end
+
+    private
+
+    def default_visualizer_path
+      exe = "rrtrace#{RbConfig::CONFIG["EXEEXT"]}"
+      File.expand_path("../libexec/#{exe}", __dir__)
+    end
   end
 end
 
 require "rrtrace/rrtrace"
+
+module Rrtrace
+  private_class_method :native_start, :native_stop, :native_started?
+end
+
+Kernel.at_exit { Rrtrace.stop }

data/mise.toml

@@ -1,8 +1,11 @@
 [tools]
-ruby = "4.0.0"
+ruby = "4.0"
 
 [tasks.setup]
 run = "bundle install"
 
 [tasks.build]
-run = "bundle exec rake build"
+run = """
+rm -rf tmp
+bundle exec rake build
+"""

data/sig/rrtrace.rbs

@@ -1,4 +1,7 @@
 module Rrtrace
   VERSION: String
   def self.visualizer_path: () -> String
+  def self.start: () -> bool
+  def self.stop: () -> bool
+  def self.started?: () -> bool
 end