asherah 3.0.0 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asherah",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Asherah envelope encryption and key rotation library",
   "exports": {
     "node-addons": "./dist/asherah.node"
@@ -32,6 +32,8 @@
     "src/hints.h",
     "src/logging.cc",
     "src/logging.h",
+    "src/logging_napi.cc",
+    "src/logging_napi.h",
     "src/napi_utils.h",
     "src/scoped_allocate.h",
     "src/asherah.d.ts",

package/src/asherah.cc

@@ -696,4 +696,4 @@ private:
 #pragma endregion Helpers
 };
 
-NODE_API_NAMED_ADDON('asherah', Asherah)
+NODE_API_NAMED_ADDON(asherah, Asherah)

package/src/logging.h

@@ -2,6 +2,8 @@
 #define LOGGING_H
 #include <sstream> // std::ostringstream
 #include <string>  // std::string
+#include <cstdint> // int32_t
+#include <cstddef> // size_t
 
 class Logger {
 public:

package/src/logging_napi.cc

@@ -0,0 +1,151 @@
+#include "logging_napi.h"
+#include "napi_utils.h"
+
+LoggerNapi::LoggerNapi(Napi::Env &env, std::string system_name)
+    : Logger(system_name), log_hook(Napi::FunctionReference()), env(env) {}
+
+LoggerNapi::LoggerNapi(Napi::Env &env, std::string system_name,
+                       Napi::Function new_log_hook)
+    : Logger(system_name), env(env) {
+  if (unlikely(new_log_hook.IsEmpty())) {
+    NapiUtils::ThrowException(env, "new_log_hook cannot be nullptr");
+  }
+  log_hook = Napi::Persistent(new_log_hook);
+}
+
+LoggerNapi::~LoggerNapi() {
+  auto old_log_hook = std::exchange(log_hook, Napi::FunctionReference());
+  if (!old_log_hook.IsEmpty()) {
+    old_log_hook.Unref();
+  }
+}
+
+void LoggerNapi::set_log_hook(Napi::Function new_log_hook) {
+  if (unlikely(new_log_hook.IsUndefined() || new_log_hook.IsEmpty())) {
+    NapiUtils::ThrowException(env, "new_log_hook cannot be empty");
+  }
+  auto old_log_hook = std::exchange(log_hook, Napi::Persistent(new_log_hook));
+  if (!old_log_hook.IsEmpty()) {
+    old_log_hook.Unref();
+  }
+}
+
+void LoggerNapi::debug_log(const char *function_name,
+                           const char *message) const {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_debug_log(function_name, message);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_debug),
+           Napi::String::New(env,
+                             system_name + function_name + ": " + message)});
+    }
+  }
+}
+
+void LoggerNapi::debug_log(const char *function_name,
+                           const std::string &message) const {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_debug_log(function_name, message);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_debug),
+           Napi::String::New(env,
+                             system_name + function_name + ": " + message)});
+    }
+  }
+}
+
+void LoggerNapi::debug_log_alloca(const char *function_name,
+                                  const char *variable_name,
+                                  size_t length) const {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_debug_log_alloca(function_name, variable_name, length);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_debug),
+           Napi::String::New(env, system_name + function_name +
+                                      ": Calling alloca(" +
+                                      std::to_string(length) +
+                                      ") (stack) for " + variable_name)});
+    }
+  }
+}
+
+void LoggerNapi::debug_log_new(const char *function_name,
+                               const char *variable_name, size_t length) const {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_debug_log_new(function_name, variable_name, length);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_debug),
+           Napi::String::New(env, system_name + function_name +
+                                      ": Calling new[" +
+                                      std::to_string(length) + "] (heap) for " +
+                                      variable_name)});
+    }
+  }
+}
+
+void LoggerNapi::error_log(const char *function_name,
+                           const char *message) const {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_error_log(function_name, message);
+    } else {
+      stderr_error_log(function_name, message);
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_error),
+           Napi::String::New(env,
+                             system_name + function_name + ": " + message)});
+    }
+  }
+}
+
+void LoggerNapi::error_log(const char *function_name,
+                           const std::string &message) const {
+  // Unconditionally log errors to stderr
+  stderr_error_log(function_name, message);
+
+  if (likely(!log_hook.IsEmpty())) {
+    Napi::Env env = log_hook.Env();
+    Napi::HandleScope scope(env);
+    Napi::Function log_hook_function = log_hook.Value();
+    log_hook_function.Call(
+        {Napi::Number::New(env, posix_log_level_error),
+         Napi::String::New(env, system_name + function_name + ": " + message)});
+  }
+}
+
+__attribute__((always_inline, noreturn)) inline void
+LoggerNapi::log_error_and_throw(const char *function_name,
+                                const std::string &error_msg) const {
+  std::string final_error_msg =
+      system_name + ": [EXCEPTION] " + function_name + (": " + error_msg);
+
+  // Unconditionally log errors to stderr
+  stderr_error_log(function_name, final_error_msg);
+
+  error_log(function_name, final_error_msg);
+
+  NapiUtils::ThrowException(env, final_error_msg);
+}

package/src/logging_napi.h

@@ -0,0 +1,43 @@
+#ifndef LOGGING_NAPI_H
+#define LOGGING_NAPI_H
+#include "hints.h"
+#include "logging.h"
+#include <napi.h>
+
+#ifndef NAPI_CPP_EXCEPTIONS
+#error Support for C++ exceptions is required
+#endif
+
+class LoggerNapi : public Logger {
+public:
+  LoggerNapi(Napi::Env &env, std::string system_name);
+  explicit LoggerNapi(Napi::Env &env, std::string system_name,
+                      Napi::Function new_log_hook);
+  ~LoggerNapi();
+
+  void set_log_hook(Napi::Function new_log_hook);
+
+  void debug_log(const char *function_name, const char *message) const override;
+  void debug_log(const char *function_name,
+                 const std::string &message) const override;
+  void debug_log_alloca(const char *function_name, const char *variable_name,
+                        size_t length) const override;
+
+  void debug_log_new(const char *function_name, const char *variable_name,
+                     size_t length) const override;
+
+  void error_log(const char *function_name, const char *message) const override;
+  void error_log(const char *function_name,
+                 const std::string &message) const override;
+  [[noreturn]] void
+  log_error_and_throw(const char *function_name,
+                      const std::string &error_msg) const override;
+
+private:
+  Napi::FunctionReference log_hook;
+  Napi::Env env;
+  const int posix_log_level_error = 3;
+  const int posix_log_level_debug = 7;
+};
+
+#endif // LOGGING_NAPI_H