feat: use instrument hooks for measurements

Author: GuillaumeLagrange

.github/workflows/ci.yml

@@ -12,7 +12,7 @@ jobs:
     steps:
       - uses: "actions/checkout@v4"
         with:
-          fetch-depth: 0
+          submodules: true
       - name: Install valgrind
         run: |
           sudo apt-get update
@@ -32,6 +32,8 @@ jobs:
       examples: ${{ steps.list-examples.outputs.examples }}
     steps:
       - uses: "actions/checkout@v4"
+        with:
+          submodules: true
       # list the directories in ./examples and output them to a github action workflow variables as a JSON array
       - run: |
           examples=$(find ./examples -maxdepth 1 -mindepth 1 -type d -printf '%f\n' | jq -R -s -c 'split("\n") | map(select(length > 0))')
@@ -50,7 +52,7 @@ jobs:
     steps:
       - uses: "actions/checkout@v4"
         with:
-          fetch-depth: 0
+          submodules: true
       - name: Install valgrind
         run: |
           sudo apt-get update

.prettierignore

@@ -2,3 +2,4 @@ node_modules
 .rollup.cache
 dist
 generated
+packages/core/src/native_core/instruments/hooks

packages/core/binding.gyp

@@ -8,14 +8,30 @@
       "cflags_cc!": [
         "-fno-exceptions"
       ],
+      "cflags": [
+        "-Wno-maybe-uninitialized",
+        "-Wno-unused-variable",
+        "-Wno-unused-parameter",
+        "-Wno-unused-but-set-variable",
+        "-Wno-type-limits"
+      ],
+      "cflags_cc": [
+        "-Wno-maybe-uninitialized",
+        "-Wno-unused-variable",
+        "-Wno-unused-parameter",
+        "-Wno-unused-but-set-variable",
+        "-Wno-type-limits"
+      ],
       "sources": [
-        "src/native_core/measurement/measurement.cc",
         "src/native_core/linux_perf/linux_perf.cc",
         "src/native_core/linux_perf/linux_perf_listener.cc",
+        "src/native_core/instruments/hooks_wrapper.cc",
+        "src/native_core/instruments/hooks/dist/core.c",
         "src/native_core/native_core.cc"
       ],
       "include_dirs": [
-        "<!@(node -p \"require('node-addon-api').include\")"
+        "<!@(node -p \"require('node-addon-api').include\")",
+        "src/native_core/instruments/hooks/includes"
       ],
       "defines": [
         "NAPI_DISABLE_CPP_EXCEPTIONS"

packages/core/src/index.ts

@@ -11,9 +11,7 @@ export const isBound = native_core.isBound;
 export const mongoMeasurement = new MongoMeasurement();
 
 export const setupCore = () => {
-  native_core.Measurement.stopInstrumentation(
-    `Metadata: codspeed-node ${__VERSION__}`
-  );
+  native_core.InstrumentHooks.setIntegration("codspeed-node", __VERSION__);
   linuxPerf.start();
   checkV8Flags();
 };
@@ -29,4 +27,4 @@ export type {
 export { getV8Flags, tryIntrospect } from "./introspection";
 export { optimizeFunction, optimizeFunctionSync } from "./optimization";
 export * from "./utils";
-export const Measurement = native_core.Measurement;
+export const InstrumentHooks = native_core.InstrumentHooks;

packages/core/src/native_core/index.ts

@@ -1,8 +1,9 @@
 import path from "path";
+import { InstrumentHooks } from "./instruments/hooks";
 import { LinuxPerf } from "./linux_perf/linux_perf";
-import { Measurement } from "./measurement/measurement";
+
 interface NativeCore {
-  Measurement: Measurement;
+  InstrumentHooks: InstrumentHooks;
   LinuxPerf: typeof LinuxPerf;
 }
 
@@ -22,12 +23,12 @@ try {
   };
 } catch (e) {
   native_core = {
-    Measurement: {
+    InstrumentHooks: {
       isInstrumented: () => false,
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      startInstrumentation: () => {},
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
-      stopInstrumentation: (at) => {},
+      startBenchmark: () => 1,
+      stopBenchmark: () => 1,
+      setExecutedBenchmark: () => 1,
+      setIntegration: () => 1,
     },
     LinuxPerf: class LinuxPerf {
       start() {

packages/core/src/native_core/instrument-hooks

@@ -0,0 +1,7 @@
+export interface InstrumentHooks {
+  isInstrumented: () => boolean;
+  startBenchmark: () => number;
+  stopBenchmark: () => number;
+  setExecutedBenchmark: (pid: number, uri: string) => number;
+  setIntegration: (name: string, version: string) => number;
+}

packages/core/src/native_core/instruments/hooks.ts

@@ -0,0 +1,137 @@
+#include "hooks_wrapper.h"
+#include "hooks/includes/core.h"
+#include <memory>
+
+namespace codspeed_native {
+namespace instruments {
+namespace hooks_wrapper {
+
+// Global instance to maintain state across calls
+static std::unique_ptr<InstrumentHooks, decltype(&instrument_hooks_deinit)>
+    g_hooks{nullptr, &instrument_hooks_deinit};
+
+// Initialize instrument hooks if not already done
+static InstrumentHooks *ensureInitialized() {
+  if (!g_hooks) {
+    InstrumentHooks *hooks = instrument_hooks_init();
+    if (hooks) {
+      g_hooks.reset(hooks);
+    }
+  }
+  return g_hooks.get();
+}
+
+Napi::Boolean IsInstrumented(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  InstrumentHooks *hooks = ensureInitialized();
+
+  if (!hooks) {
+    return Napi::Boolean::New(env, false);
+  }
+
+  bool instrumented = instrument_hooks_is_instrumented(hooks);
+  return Napi::Boolean::New(env, instrumented);
+}
+
+Napi::Number StartBenchmark(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  InstrumentHooks *hooks = ensureInitialized();
+
+  if (!hooks) {
+    return Napi::Number::New(env, 1); // Return error code
+  }
+
+  uint8_t result = instrument_hooks_start_benchmark(hooks);
+  return Napi::Number::New(env, result);
+}
+
+Napi::Number StopBenchmark(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  InstrumentHooks *hooks = ensureInitialized();
+
+  if (!hooks) {
+    return Napi::Number::New(env, 1); // Return error code
+  }
+
+  uint8_t result = instrument_hooks_stop_benchmark(hooks);
+  return Napi::Number::New(env, result);
+}
+
+Napi::Number SetExecutedBenchmark(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() != 2) {
+    Napi::TypeError::New(env, "Expected 2 arguments: pid and uri")
+        .ThrowAsJavaScriptException();
+    return Napi::Number::New(env, 1);
+  }
+
+  if (!info[0].IsNumber() || !info[1].IsString()) {
+    Napi::TypeError::New(env, "Expected number (pid) and string (uri)")
+        .ThrowAsJavaScriptException();
+    return Napi::Number::New(env, 1);
+  }
+
+  InstrumentHooks *hooks = ensureInitialized();
+  if (!hooks) {
+    return Napi::Number::New(env, 1);
+  }
+
+  uint32_t pid = info[0].As<Napi::Number>().Uint32Value();
+  std::string uri = info[1].As<Napi::String>().Utf8Value();
+
+  uint8_t result =
+      instrument_hooks_set_executed_benchmark(hooks, pid, uri.c_str());
+  return Napi::Number::New(env, result);
+}
+
+Napi::Number SetIntegration(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() != 2) {
+    Napi::TypeError::New(env, "Expected 2 arguments: name and version")
+        .ThrowAsJavaScriptException();
+    return Napi::Number::New(env, 1);
+  }
+
+  if (!info[0].IsString() || !info[1].IsString()) {
+    Napi::TypeError::New(env, "Expected string (name) and string (version)")
+        .ThrowAsJavaScriptException();
+    return Napi::Number::New(env, 1);
+  }
+
+  InstrumentHooks *hooks = ensureInitialized();
+  if (!hooks) {
+    return Napi::Number::New(env, 1);
+  }
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+  std::string version = info[1].As<Napi::String>().Utf8Value();
+
+  uint8_t result =
+      instrument_hooks_set_integration(hooks, name.c_str(), version.c_str());
+  return Napi::Number::New(env, result);
+}
+
+Napi::Object Initialize(Napi::Env env, Napi::Object exports) {
+  Napi::Object instrumentHooksObj = Napi::Object::New(env);
+
+  instrumentHooksObj.Set(Napi::String::New(env, "isInstrumented"),
+                         Napi::Function::New(env, IsInstrumented));
+  instrumentHooksObj.Set(Napi::String::New(env, "startBenchmark"),
+                         Napi::Function::New(env, StartBenchmark));
+  instrumentHooksObj.Set(Napi::String::New(env, "stopBenchmark"),
+                         Napi::Function::New(env, StopBenchmark));
+  instrumentHooksObj.Set(Napi::String::New(env, "setExecutedBenchmark"),
+                         Napi::Function::New(env, SetExecutedBenchmark));
+  instrumentHooksObj.Set(Napi::String::New(env, "setIntegration"),
+                         Napi::Function::New(env, SetIntegration));
+
+  exports.Set(Napi::String::New(env, "InstrumentHooks"), instrumentHooksObj);
+
+  return exports;
+}
+
+} // namespace hooks_wrapper
+} // namespace instruments
+} // namespace codspeed_native

packages/core/src/native_core/instruments/hooks_wrapper.cc

@@ -0,0 +1,21 @@
+#ifndef INSTRUMENTS_HOOKS_WRAPPER_H
+#define INSTRUMENTS_HOOKS_WRAPPER_H
+
+#include <napi.h>
+
+namespace codspeed_native {
+namespace instruments {
+namespace hooks_wrapper {
+
+Napi::Boolean IsInstrumented(const Napi::CallbackInfo &info);
+Napi::Number StartBenchmark(const Napi::CallbackInfo &info);
+Napi::Number StopBenchmark(const Napi::CallbackInfo &info);
+Napi::Number SetExecutedBenchmark(const Napi::CallbackInfo &info);
+Napi::Number SetIntegration(const Napi::CallbackInfo &info);
+Napi::Object Initialize(Napi::Env env, Napi::Object exports);
+
+} // namespace hooks_wrapper
+} // namespace instruments
+} // namespace codspeed_native
+
+#endif // INSTRUMENTS_HOOKS_WRAPPER_H

packages/core/src/native_core/instruments/hooks_wrapper.h

@@ -1,12 +1,12 @@
 #include "linux_perf/linux_perf.h"
-#include "measurement/measurement.h"
+#include "instruments/hooks_wrapper.h"
 #include <napi.h>
 
 namespace codspeed_native {
 
 Napi::Object Initialize(Napi::Env env, Napi::Object exports) {
   codspeed_native::LinuxPerf::Initialize(env, exports);
-  codspeed_native::Measurement::Initialize(env, exports);
+  codspeed_native::instruments::hooks_wrapper::Initialize(env, exports);
 
   return exports;
 }