chore: add callback registration to passert_failure to enable dumping rapidcheck test input (#5532)

Resolves CORE-233.

A `passert` failure crashes the process without returning. While
`Catch2` has a `SIGABRT` handler to print some details around this,
`rapidcheck` does not. As such, if a randomized `rapidcheck` input fails
a `passert`, no details about what the input was are printed.

Ostensibly we have some means of recovering that failed input using the
seed which produced the test case, but this might not be helpful:
1) we don't know if it is platform-independent
2) if there is a non-deterministic or undefined behavior leading to
failure, then the seed may not be enough to clue us in

This pull request adds a callback registration to `passert_failure` so
that we can register a callback in our `rapidcheck` properties to print
the last attempted input in the event of a `passert` failure. This way
we can recover a bad input with certainty.

Example:
```
FATAL TileDB core library internal error: false
  test/src/unit-sparse-global-order-reader.cc:1396
Last rapidcheck input: (2, 1, 1, [[1, 1]], d1 LT 0x01 0x00 0x00 0x00)
```

---
TYPE: NO_HISTORY
DESC: add callback registration to `passert_failure` to enable dumping
rapidcheck test input

Author: rroelke

test/src/unit-sparse-global-order-reader.cc

@@ -1311,6 +1311,20 @@ TEST_CASE_METHOD(
   CHECK(retrieved_data == expected_correct_data);
 }
 
+template <typename... Args>
+struct PAssertFailureCallbackShowRapidcheckInput {
+  std::tuple<const Args&...> inputs_;
+
+  PAssertFailureCallbackShowRapidcheckInput(const Args&... inputs)
+      : inputs_(inputs...) {
+  }
+
+  void operator()() const {
+    std::cerr << "Last rapidcheck input: ";
+    rc::show<decltype(inputs_)>(inputs_, std::cerr);
+  }
+};
+
 /**
  * Tests that the reader will not yield results out of order across multiple
  * iterations or `submit`s if the fragments are heavily skewed when the memory
@@ -1335,6 +1349,10 @@ TEST_CASE_METHOD(
                   const std::vector<templates::Domain<int>>& subarray =
                       std::vector<templates::Domain<int>>(),
                   tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
+    PAssertFailureCallbackRegistration showInput(
+        PAssertFailureCallbackShowRapidcheckInput(
+            fragment_size, num_user_cells, extent, subarray, *condition.get()));
+
     // Write a fragment F0 with unique coordinates
     templates::Fragment1D<int, int> fragment0;
     fragment0.dim_.resize(fragment_size);
@@ -1438,6 +1456,10 @@ TEST_CASE_METHOD(
                   size_t num_user_cells,
                   const std::vector<templates::Domain<int>>& subarray = {},
                   tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
+    PAssertFailureCallbackRegistration showInput(
+        PAssertFailureCallbackShowRapidcheckInput(
+            fragment_size, num_user_cells, subarray, *condition.get()));
+
     templates::Fragment1D<int, int> fragment0;
     templates::Fragment1D<int, int> fragment1;
 
@@ -1537,6 +1559,15 @@ TEST_CASE_METHOD(
                   const std::vector<templates::Domain<int>>& subarray =
                       std::vector<templates::Domain<int>>(),
                   tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
+    PAssertFailureCallbackRegistration showInput(
+        PAssertFailureCallbackShowRapidcheckInput(
+            num_fragments,
+            fragment_size,
+            num_user_cells,
+            allow_dups,
+            subarray,
+            *condition.get()));
+
     const uint64_t total_budget = 100000;
     const double ratio_coords = 0.2;
 
@@ -1656,6 +1687,16 @@ TEST_CASE_METHOD(
                   bool allow_dups,
                   const Subarray1DType<int>& subarray = {},
                   tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
+    PAssertFailureCallbackRegistration showInput(
+        PAssertFailureCallbackShowRapidcheckInput(
+            num_fragments,
+            fragment_size,
+            num_user_cells,
+            tile_capacity,
+            allow_dups,
+            subarray,
+            *condition.get()));
+
     FxRun1D instance;
     instance.num_user_cells = num_user_cells;
     instance.subarray = subarray;
@@ -1817,6 +1858,18 @@ TEST_CASE_METHOD(
                   bool allow_dups,
                   const Subarray2DType<int, int>& subarray = {},
                   tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
+    PAssertFailureCallbackRegistration showInput(
+        PAssertFailureCallbackShowRapidcheckInput(
+            tile_order,
+            cell_order,
+            num_fragments,
+            fragment_size,
+            num_user_cells,
+            tile_capacity,
+            allow_dups,
+            subarray,
+            *condition.get()));
+
     FxRun2D instance;
     instance.num_user_cells = num_user_cells;
     instance.capacity = tile_capacity;
@@ -1981,6 +2034,18 @@ TEST_CASE_METHOD(
                   bool allow_dups,
                   const Subarray2DType<int, int>& subarray = {},
                   tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
+    PAssertFailureCallbackRegistration showInput(
+        PAssertFailureCallbackShowRapidcheckInput(
+            tile_order,
+            cell_order,
+            approximate_memory_tiles,
+            num_user_cells,
+            num_fragments,
+            tile_capacity,
+            allow_dups,
+            subarray,
+            *condition.get()));
+
     FxRun2D instance;
     instance.tile_order_ = tile_order;
     instance.cell_order_ = cell_order;
@@ -2128,6 +2193,10 @@ TEST_CASE_METHOD(
                   templates::Dimension<Datatype::INT64> dimension,
                   const Subarray1DType<int64_t>& subarray = {},
                   tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
+    PAssertFailureCallbackRegistration showInput(
+        PAssertFailureCallbackShowRapidcheckInput(
+            num_fragments, dimension, subarray, *condition.get()));
+
     const size_t fragment_size =
         std::min<size_t>(1024 * 32, dimension.domain.num_cells());
 
@@ -3072,7 +3141,11 @@ TEST_CASE_METHOD(
     "fragments",
     "[sparse-global-order][sub-millisecond][rest][rapidcheck]") {
   auto doit = [this]<typename Asserter>(
-                  const std::vector<uint64_t> fragment_same_timestamp_runs) {
+                  const std::vector<uint64_t>& fragment_same_timestamp_runs) {
+    PAssertFailureCallbackRegistration showInput{
+        PAssertFailureCallbackShowRapidcheckInput(
+            fragment_same_timestamp_runs)};
+
     uint64_t num_fragments = 0;
     for (const auto same_timestamp_run : fragment_same_timestamp_runs) {
       num_fragments += same_timestamp_run;

tiledb/common/assert.cc

@@ -31,6 +31,9 @@
 
 #include "tiledb/common/assert.h"
 
+#include <mutex>
+#include <vector>
+
 namespace tiledb::common {
 
 AssertFailure::AssertFailure(const std::string& what)
@@ -42,12 +45,43 @@ AssertFailure::AssertFailure(const std::string& what)
   throw AssertFailure(file, line, expr);
 }
 
+static std::mutex passertFailureCallbackMutex;
+static std::vector<std::function<void()>> passertFailureCallbacks;
+
+[[noreturn]] void passert_failure_abort(void) {
+  {
+    for (auto& callback : passertFailureCallbacks) {
+      std::unique_lock<std::mutex> lk(passertFailureCallbackMutex);
+      callback();
+    }
+  }
+
+  std::abort();
+}
+
 [[noreturn]] void passert_failure(
     const char* file, uint64_t line, const char* expr) {
   std::cerr << "FATAL TileDB core library internal error: " << expr
             << std::endl;
   std::cerr << "  " << file << ":" << line << std::endl;
-  std::abort();
+
+  passert_failure_abort();
+}
+
+#ifdef TILEDB_ASSERTIONS
+
+PAssertFailureCallbackRegistration::PAssertFailureCallbackRegistration(
+    std::function<void()>&& callback) {
+  std::unique_lock<std::mutex> lk(passertFailureCallbackMutex);
+  passertFailureCallbacks.push_back(
+      std::forward<std::function<void()>>(callback));
 }
 
+PAssertFailureCallbackRegistration::~PAssertFailureCallbackRegistration() {
+  std::unique_lock<std::mutex> lk(passertFailureCallbackMutex);
+  passertFailureCallbacks.pop_back();
+}
+
+#endif
+
 }  // namespace tiledb::common

tiledb/common/assert.h

@@ -88,6 +88,7 @@
 
 #include <fmt/format.h>
 #include <cstdlib>
+#include <functional>
 #include <iostream>
 
 #define __SOURCE__ (&__FILE__[__SOURCE_DIR_PATH_SIZE__])
@@ -168,6 +169,11 @@ template <typename... Args>
   throw AssertFailure(file, line, expr, fmt, std::forward<Args>(fmt_args)...);
 }
 
+/**
+ * Aborts the process upon `passert` failure.
+ */
+[[noreturn]] void passert_failure_abort(void);
+
 /**
  * Assertion failure which results in a process panic.
  * SIGABRT is raised.
@@ -203,9 +209,24 @@ template <typename... Args>
   std::cerr << "  " << file << ":" << line << std::endl;
   std::cerr << "  Details: "
             << fmt::format(fmt, std::forward<Args>(fmt_args)...) << std::endl;
-  std::abort();
+
+  passert_failure_abort();
 }
 
+/**
+ * Registers a callback to run upon `passert` failure.
+ * This can be used to print any diagnostic info prior to aborting the process.
+ */
+struct PAssertFailureCallbackRegistration {
+#ifdef TILEDB_ASSERTIONS
+  PAssertFailureCallbackRegistration(std::function<void()>&& callback);
+  ~PAssertFailureCallbackRegistration();
+#else
+  PAssertFailureCallbackRegistration(std::function<void()>&&) {
+  }
+#endif
+};
+
 }  // namespace tiledb::common
 
 #ifdef TILEDB_ASSERTIONS