asherah 3.0.2 → 3.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asherah",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "Asherah envelope encryption and key rotation library",
   "exports": {
     "node-addons": "./dist/asherah.node"

package/src/asherah.cc

@@ -82,9 +82,13 @@ private:
 
       // extern GoInt32 SetupJson(void* configJson);
       GoInt32 result = SetupJson(config);
-      EndSetupAsherah(result, product_id_length, service_name_length);
+      EndSetupAsherah(env, result, product_id_length, service_name_length);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
     }
   }
 
@@ -105,8 +109,12 @@ private:
                                            service_name_length);
       worker->Queue();
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -116,9 +124,13 @@ private:
     try {
       BeginShutdownAsherah(env, __func__, info);
       Shutdown();
-      EndShutdownAsherah();
+      EndShutdownAsherah(env);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
     }
   }
 
@@ -130,8 +142,12 @@ private:
       auto worker = new ShutdownAsherahWorker(env, this);
       worker->Queue();
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -189,9 +205,12 @@ private:
       GoInt32 result = EncryptToJson(partition_id, input, output);
 
       EndEncryptToJson(env, output, result, output_string);
-
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
 
     return output_string;
@@ -220,8 +239,12 @@ private:
           new EncryptAsherahWorker(env, this, partition_id, input, output);
       worker->Queue();
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -272,12 +295,17 @@ private:
       // void* dataPtr);
       GoInt32 result = DecryptFromJson(partition_id, input, output);
 
-      CheckResult(result);
+      CheckResult(env, result);
 
       output_value = output.ToBuffer(env); // NOLINT(*-slicing)
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
+
     return output_value;
   }
 
@@ -298,8 +326,12 @@ private:
           env, this, partition_id, input, output);
       worker->Queue();
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -310,10 +342,6 @@ private:
     try {
       NapiUtils::RequireParameterCount(info, 2);
 
-      if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-        logger.log_error_and_throw(__func__, "Wrong argument types");
-      }
-
       Napi::String partition_id_string;
       Napi::Value input_value;
       BeginDecryptFromJson(env, __func__, info, partition_id_string,
@@ -349,8 +377,12 @@ private:
       GoInt32 result = DecryptFromJson(partition_id, input, output);
 
       EndDecryptFromJson(env, output, result, output_string);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
     return output_string;
   }
@@ -361,10 +393,6 @@ private:
     try {
       NapiUtils::RequireParameterCount(info, 2);
 
-      if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-        logger.log_error_and_throw(__func__, "Wrong argument types");
-      }
-
       Napi::String partition_id_string;
       Napi::Value input_value;
       BeginDecryptFromJson(env, __func__, info, partition_id_string,
@@ -380,8 +408,12 @@ private:
       worker->Queue();
 
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -392,6 +424,7 @@ private:
     auto new_size = (size_t)item_size.Int32Value();
 
     maximum_stack_alloc_size = new_size;
+    //TODO: This needs exception handling consistent with other methods
   }
 
   void SetSafetyPaddingOverhead(const Napi::CallbackInfo &info) {
@@ -408,23 +441,25 @@ private:
                      &info) { // NOLINT(*-convert-member-functions-to-static)
     int32_t setup_status = setup_state.load(std::memory_order_acquire);
     return Napi::Boolean::New(info.Env(), setup_status != 0);
+    //TODO: This needs exception handling consistent with other methods
   }
 
   void SetLogHook(const Napi::CallbackInfo &info) {
     NapiUtils::RequireParameterCount(info, 1);
 
     if (unlikely(!info[0].IsFunction())) {
-      logger.log_error_and_throw(__func__, "Wrong argument type");
+      NapiUtils::ThrowException(info.Env(), "Expected a function");
     }
 
     logger.set_log_hook(info[0].As<Napi::Function>());
+    //TODO: This needs exception handling consistent with other methods
   }
 
   void BeginSetupAsherah(const Napi::Env &env, const char *func_name,
                          const Napi::CallbackInfo &info,
                          Napi::String &config_string, size_t &product_id_length,
                          size_t &service_name_length) {
-    RequireAsherahNotSetup(func_name);
+    RequireAsherahNotSetup(env, func_name);
 
     NapiUtils::RequireParameterCount(info, 1);
 
@@ -444,22 +479,22 @@ private:
     verbose_flag = verbose;
   }
 
-  void EndSetupAsherah(GoInt32 result, size_t product_id_length,
-                       size_t service_name_length) {
-    CheckResult(result);
+  void EndSetupAsherah(const Napi::Env &env, GoInt32 result,
+                       size_t product_id_length, size_t service_name_length) {
+    CheckResult(env, result);
 
     est_intermediate_key_overhead = product_id_length + service_name_length;
 
     auto old_setup_state = setup_state.exchange(1, std::memory_order_acq_rel);
     if (unlikely(old_setup_state != 0)) {
-      logger.log_error_and_throw(__func__, "lost race to mark setup_state!");
+      NapiUtils::ThrowException(env, "EndSetupAsherah: lost race to mark setup_state?!");
     }
   }
 
   void BeginEncryptToJson(const Napi::Env &env, const char *func_name,
                           const Napi::CallbackInfo &info,
                           Napi::String &partition_id, Napi::Value &input) {
-    RequireAsherahSetup(func_name);
+    RequireAsherahSetup(env, func_name);
 
     NapiUtils::RequireParameterCount(info, 2);
 
@@ -469,14 +504,14 @@ private:
 
   void EndEncryptToJson(Napi::Env env, CobhanBufferNapi &output, GoInt32 result,
                         Napi::String &output_string) {
-    CheckResult(result);
+    CheckResult(env, result);
 
     output_string = output.ToString(env);
   }
 
   void EndEncryptToJson(Napi::Env env, CobhanBufferNapi &output, GoInt32 result,
                         Napi::Buffer<unsigned char> &output_buffer) {
-    CheckResult(result);
+    CheckResult(env, result);
 
     output_buffer = output.ToBuffer(env);
   }
@@ -484,7 +519,7 @@ private:
   void BeginDecryptFromJson(const Napi::Env &env, const char *func_name,
                             const Napi::CallbackInfo &info,
                             Napi::String &partition_id, Napi::Value &input) {
-    RequireAsherahSetup(func_name);
+    RequireAsherahSetup(env, func_name);
 
     NapiUtils::RequireParameterCount(info, 2);
 
@@ -495,28 +530,28 @@ private:
   void EndDecryptFromJson(Napi::Env &env, CobhanBufferNapi &output,
                           GoInt32 result,
                           Napi::Buffer<unsigned char> &output_buffer) {
-    CheckResult(result);
+    CheckResult(env, result);
 
     output_buffer = output.ToBuffer(env);
   }
 
   void EndDecryptFromJson(Napi::Env &env, CobhanBufferNapi &output,
                           GoInt32 result, Napi::String &output_string) {
-    CheckResult(result);
+    CheckResult(env, result);
 
     output_string = output.ToString(env);
   }
 
-  void BeginShutdownAsherah(const Napi::Env &, const char *func_name,
+  void BeginShutdownAsherah(const Napi::Env &env, const char *func_name,
                             const Napi::CallbackInfo &info) {
-    RequireAsherahSetup(func_name);
+    RequireAsherahSetup(env, func_name);
     NapiUtils::RequireParameterCount(info, 0);
   }
 
-  void EndShutdownAsherah() {
+  void EndShutdownAsherah(Napi::Env &env) {
     auto old_setup_state = setup_state.exchange(0, std::memory_order_acq_rel);
     if (unlikely(old_setup_state == 0)) {
-      logger.log_error_and_throw(__func__, "lost race to mark setup_state!");
+      NapiUtils::ThrowException(env, "EndSetupAsherah: lost race to mark setup_state?!");
     }
   }
 
@@ -536,7 +571,8 @@ private:
     GoInt32 ExecuteTask() override { return SetupJson(config); }
 
     Napi::Value OnOKTask(Napi::Env &env) override {
-      asherah->EndSetupAsherah(result, product_id_length, service_name_length);
+      asherah->EndSetupAsherah(env, result, product_id_length,
+                               service_name_length);
       return env.Undefined();
     }
 
@@ -610,7 +646,7 @@ private:
     }
 
     Napi::Value OnOKTask(Napi::Env &env) override {
-      asherah->EndShutdownAsherah();
+      asherah->EndShutdownAsherah(env);
       return env.Undefined();
     }
   };
@@ -619,21 +655,21 @@ private:
 
 #pragma region Helpers
 
-  void CheckResult(GoInt32 result) {
+  void CheckResult(const Napi::Env &env, GoInt32 result) {
     if (unlikely(result < 0)) {
-      logger.log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
+      NapiUtils::ThrowException(env, AsherahCobhanErrorToString(result));
     }
   }
 
-  void RequireAsherahSetup(const char *func_name) {
+  void RequireAsherahSetup(const Napi::Env &env, const char *func_name) {
     if (unlikely(setup_state.load(std::memory_order_acquire) == 0)) {
-      logger.log_error_and_throw(func_name, "setup() not called");
+      NapiUtils::ThrowException(env, "RequireAsherahSetup: setup() not called");
     }
   }
 
-  void RequireAsherahNotSetup(const char *func_name) {
+  void RequireAsherahNotSetup(const Napi::Env &env, const char *func_name) {
     if (unlikely(setup_state.load(std::memory_order_acquire) != 0)) {
-      logger.log_error_and_throw(func_name, "setup() already called");
+      NapiUtils::ThrowException(env, "RequireAsherahNotSetup: setup() already called");
     }
   }
 

package/src/asherah_async_worker.h

@@ -32,7 +32,7 @@ protected:
 private:
   Napi::Promise::Deferred deferred;
 
-  void Execute() override final {
+  void Execute() final {
     try {
       result = ExecuteTask();
     } catch (const std::exception &ex) {
@@ -40,7 +40,7 @@ private:
     }
   }
 
-  void OnOK() override final {
+  void OnOK() final {
     Napi::Env env = Env();
     Napi::HandleScope scope(env);
     try {
@@ -51,7 +51,7 @@ private:
     }
   }
 
-  void OnError(Napi::Error const &error) override final {
+  void OnError(Napi::Error const &error) final {
     Napi::Env env = Env();
     Napi::HandleScope scope(Env());
     try {

package/src/cobhan_buffer.h

@@ -61,7 +61,7 @@ public:
     cleanup();
   }
 
-  std::string DebugPrintStdErr() const {
+    __attribute__((unused)) std::string DebugPrintStdErr() const {
     auto debug_string = std::string(get_data_ptr(), get_data_len_bytes());
     std::ostringstream debug_output;
     debug_output << "CobhanBuffer { " << std::endl

package/src/logging.cc

@@ -4,12 +4,11 @@
 
 void Logger::set_verbose_flag(int32_t verbose) { verbose_flag = verbose != 0; }
 
-Logger::Logger(std::string system_name) : system_name(system_name) {
+Logger::Logger(const std::string &system_name) : system_name(system_name) {
   std::cerr << "Created logger for " << system_name << std::endl << std::flush;
 }
 
-__attribute__((always_inline)) inline void
-Logger::stderr_debug_log(const char *function_name, const char *message) const {
+void Logger::stderr_debug_log(const char *function_name, const char *message) const {
   if (unlikely(verbose_flag)) {
     std::cerr << system_name << ": [DEBUG] " << function_name << ": " << message
               << std::endl
@@ -17,8 +16,7 @@ Logger::stderr_debug_log(const char *function_name, const char *message) const {
   }
 }
 
-__attribute__((always_inline)) inline void
-Logger::stderr_debug_log(const char *function_name,
+void Logger::stderr_debug_log(const char *function_name,
                          const std::string &message) const {
   if (unlikely(verbose_flag)) {
     std::cerr << system_name << ": [DEBUG] " << function_name << ": " << message
@@ -27,7 +25,7 @@ Logger::stderr_debug_log(const char *function_name,
   }
 }
 
-__attribute__((always_inline)) inline void Logger::stderr_debug_log_alloca(
+void Logger::stderr_debug_log_alloca(
     const char *function_name, const char *variable_name, size_t length) const {
   if (unlikely(verbose_flag)) {
     std::cerr << system_name << ": [DEBUG] " << function_name
@@ -37,8 +35,7 @@ __attribute__((always_inline)) inline void Logger::stderr_debug_log_alloca(
   }
 }
 
-__attribute__((always_inline)) inline void
-Logger::stderr_debug_log_new(const char *function_name,
+void Logger::stderr_debug_log_new(const char *function_name,
                              const char *variable_name, size_t length) const {
   if (unlikely(verbose_flag)) {
     std::cerr << system_name << ": [DEBUG] " << function_name
@@ -48,15 +45,13 @@ Logger::stderr_debug_log_new(const char *function_name,
   }
 }
 
-__attribute__((always_inline)) inline void
-Logger::stderr_error_log(const char *function_name, const char *message) const {
+void Logger::stderr_error_log(const char *function_name, const char *message) const {
   std::cerr << system_name << ": [ERROR] " << function_name << ": " << message
             << std::endl
             << std::flush;
 }
 
-__attribute__((always_inline)) inline void
-Logger::stderr_error_log(const char *function_name,
+void Logger::stderr_error_log(const char *function_name,
                          const std::string &message) const {
   std::cerr << system_name << ": [ERROR] " << function_name << ": " << message
             << std::endl

package/src/logging.h

@@ -25,9 +25,6 @@ public:
                          const char *message) const = 0;
   virtual void error_log(const char *function_name,
                          const std::string &message) const = 0;
-  [[noreturn]] virtual void
-  log_error_and_throw(const char *function_name,
-                      const std::string &error_msg) const = 0;
 
   __attribute__((always_inline)) inline static std::string
   format_ptr(const void *ptr) {
@@ -37,9 +34,9 @@ public:
   }
 
 protected:
-  Logger(std::string system_name);
+  explicit Logger(const std::string &system_name);
 
-  bool verbose_flag = 0;
+  bool verbose_flag = false;
   std::string system_name;
 
   void stderr_debug_log(const char *function_name, const char *message) const;

package/src/logging_napi.cc

@@ -8,7 +8,7 @@ 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");
+    NapiUtils::ThrowException(env, system_name + ": new_log_hook cannot be nullptr");
   }
   log_hook = Napi::Persistent(new_log_hook);
 }
@@ -22,7 +22,7 @@ LoggerNapi::~LoggerNapi() {
 
 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");
+    NapiUtils::ThrowException(env, system_name + ": new_log_hook cannot be empty");
   }
   auto old_log_hook = std::exchange(log_hook, Napi::Persistent(new_log_hook));
   if (!old_log_hook.IsEmpty()) {
@@ -30,19 +30,23 @@ void LoggerNapi::set_log_hook(Napi::Function new_log_hook) {
   }
 }
 
+void LoggerNapi::call_log_hook(int level, const std::string &message) const {
+  if (unlikely(log_hook.IsEmpty())) {
+    NapiUtils::ThrowException(env, system_name + ": log_hook cannot be empty");
+  }
+  Napi::HandleScope scope(env);
+  Napi::Function log_hook_function = log_hook.Value();
+  log_hook_function.Call({Napi::Number::New(env, level),
+                          Napi::String::New(env, system_name + ": " + message)});
+}
+
 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)});
+      call_log_hook(posix_log_level_debug, system_name + ": " + function_name + ": " + message);
     }
   }
 }
@@ -53,13 +57,7 @@ void LoggerNapi::debug_log(const char *function_name,
     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)});
+      call_log_hook(posix_log_level_debug, system_name + ": " + function_name + ": " + message);
     }
   }
 }
@@ -71,15 +69,10 @@ void LoggerNapi::debug_log_alloca(const char *function_name,
     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)});
+      call_log_hook(posix_log_level_debug, system_name + ": " + function_name +
+                                              ": Calling alloca(" +
+                                              std::to_string(length) +
+                                              ") (stack) for " + variable_name);
     }
   }
 }
@@ -90,62 +83,24 @@ void LoggerNapi::debug_log_new(const char *function_name,
     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)});
+      call_log_hook(posix_log_level_debug, 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)});
-    }
+  if (likely(!log_hook.IsEmpty())) {
+    call_log_hook(posix_log_level_error, 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)});
+    call_log_hook(posix_log_level_error, 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

@@ -29,11 +29,9 @@ public:
   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:
+  void call_log_hook(int level, const std::string &message) const;
   Napi::FunctionReference log_hook;
   Napi::Env env;
   const int posix_log_level_error = 3;

package/src/napi_utils.h

@@ -4,7 +4,7 @@
 #include "hints.h"
 #include <napi.h>
 #include <stdexcept>
-
+#include <string>
 #ifndef NAPI_CPP_EXCEPTIONS
 #error Support for C++ exceptions is required
 #endif
@@ -26,10 +26,8 @@ public:
 
   [[noreturn]] static void ThrowException(const Napi::Env &env,
                                           const std::string &message) {
-    auto error = Napi::Error::New(env, message);
-    error.ThrowAsJavaScriptException();
-    // If the JavaScript exception isn't thrown, fallback to a C++ exception
-    throw error;
+    //throw std::runtime_error(message);
+    throw Napi::Error::New(env, message);
   }
 
   static void AsJsonObjectAndString(const Napi::Env &env,
@@ -116,25 +114,25 @@ public:
     if (likely(value.IsString())) {
       return value.As<Napi::String>();
     } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, "Expected String but received undefined");
+      ThrowException(env, std::string(func_name) + ": Expected String but received undefined");
     } else if (unlikely(value.IsNull())) {
-      ThrowException(env, "Expected String but received null");
+      ThrowException(env, std::string(func_name) + ": Expected String but received null");
     } else {
-      ThrowException(env, "Expected String but received unknown type");
+      ThrowException(env, std::string(func_name) + ": Expected String but received unknown type");
     }
   }
 
-  static Napi::Buffer<unsigned char>
+    __attribute__((unused)) static Napi::Buffer<unsigned char>
   RequireParameterBuffer(const Napi::Env &env, const char *func_name,
                          Napi::Value value) {
     if (likely(value.IsBuffer())) {
       return value.As<Napi::Buffer<unsigned char>>();
     } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, "Expected String but received undefined");
+      ThrowException(env, std::string(func_name) + ": Expected String but received undefined");
     } else if (unlikely(value.IsNull())) {
-      ThrowException(env, "Expected String but received null");
+      ThrowException(env, std::string(func_name) + ": Expected String but received null");
     } else {
-      ThrowException(env, "Expected String but received unknown type");
+      ThrowException(env, std::string(func_name) + ": Expected String but received unknown type");
     }
   }
 
@@ -144,13 +142,13 @@ public:
     if (value.IsString()) {
       return value.As<Napi::String>();
     } else if (likely(value.IsBuffer())) {
-      return value.As<Napi::Buffer<unsigned char>>();
+      return value.As<Napi::Buffer<unsigned char>>(); // NOLINT(*-slicing)
     } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, "Expected String but received undefined");
+      ThrowException(env, std::string(func_name) + ": Expected String but received undefined");
     } else if (unlikely(value.IsNull())) {
-      ThrowException(env, "Expected String but received null");
+      ThrowException(env, std::string(func_name) + ": Expected String but received null");
     } else {
-      ThrowException(env, "Expected String but received unknown type");
+      ThrowException(env, std::string(func_name) + ": Expected String but received unknown type");
     }
   }
 

package/src/scoped_allocate.h

@@ -1,8 +1,6 @@
 #ifndef SCOPED_ALLOCATE_H
 #define SCOPED_ALLOCATE_H
 
-#include "logging.h"
-
 /*
   This macro allows us to allocate a buffer either on the stack or on the heap.
   If the requested buffer size is less than max_stack_alloc_size, we create the
@@ -24,23 +22,20 @@
       /* If the buffer is small enough, allocate it on the stack */            \
       logger.debug_log_alloca(function_name, #buffer, buffer_size);            \
       buffer = (char *)alloca(buffer_size);                                    \
+      throw std::runtime_error("alloca(" + std::to_string(buffer_size) +       \
+                               ") returned null");                             \
     } else {                                                                   \
       /* Otherwise, allocate it on the heap */                                 \
       logger.debug_log_new(function_name, #buffer, buffer_size);               \
       buffer = new (std::nothrow) char[buffer_size];                           \
       if (unlikely(buffer == nullptr)) {                                       \
-        std::string error_msg =                                                \
-            "new[" + std::to_string(buffer_size) + "] returned null";          \
-        logger.log_error_and_throw(function_name, error_msg);                  \
-        break;                                                                 \
+        std::string error_msg = std::string(function_name) + "new[" +          \
+                                std::to_string(buffer_size) +                  \
+                                "] returned null";                             \
+        throw std::runtime_error(error_msg);                                   \
       }                                                                        \
       unique_ptr.reset(buffer);                                                \
     }                                                                          \
-    if (unlikely(buffer == nullptr)) {                                         \
-      logger.log_error_and_throw(function_name,                                \
-                                 "Failed to allocate " #buffer);               \
-      break;                                                                   \
-    }                                                                          \
   } while (0)
 
 #define SCOPED_ALLOCATE_BUFFER(logger, buffer, buffer_size,                    \