@janssenproject/cedarling_wasm 0.0.473 → 0.0.474

package/README.md

@@ -357,6 +357,27 @@ try {
 The optional TTL is a `bigint` number of seconds; omitting it uses the configured
 default. Retrieval returns `null` when a value is absent or expired.
 
+### Metrics Snapshot
+
+Destructive read: returns a metrics snapshot and resets the counters.
+
+```ts
+try {
+  const snapshot = cedarling.drainMetrics();
+  console.log(snapshot.operational_stats.get("authz.requests_total"));
+  console.log(snapshot.interval_secs);
+} catch (error) {
+  console.error("Metrics snapshot failed", error);
+}
+```
+
+Requires `CEDARLING_METRICS_COLLECTION: "enabled"`. Fails whenever
+`CEDARLING_LOCK_TELEMETRY_INTERVAL` is set, even if the Lock server has no
+telemetry endpoint. `interval_secs` is a plain `Number` (not `BigInt`), so
+`snapshot.interval_secs + 1` works. It carries fractional seconds, so
+sub-second intervals are reported exactly. Use `snapshot.jsonString()` for a
+JSON-serializable form with plain objects.
+
 ### Trusted Issuer Readiness
 
 Before token-based authorization, inspect which configured issuers loaded and

package/dist/browser/index.js

@@ -704,6 +704,38 @@ var Cedarling = class _Cedarling {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * Destructive read: returns the telemetry metrics snapshot and resets
+   * the counters for the next interval.
+   *
+   * Fails when `CEDARLING_METRICS_COLLECTION` is disabled or whenever
+   * `CEDARLING_LOCK_TELEMETRY_INTERVAL` is set (even if the Lock server
+   * has no telemetry endpoint). `interval_secs` is fractional seconds,
+   * so sub-second intervals are reported exactly.
+   *
+   * # Example
+   *
+   * ```javascript
+   * const snapshot = cedarling.drainMetrics();
+   * console.log(`Requests: ${snapshot.operational_stats.get("authz.requests_total")}`);
+   * ```
+   * @returns {MetricsSnapshot}
+   */
+  drainMetrics() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.cedarling_drainMetrics(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return MetricsSnapshot.__wrap(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
   /**
    * Get trusted issuer identifiers that failed to load.
    *
@@ -1820,6 +1852,119 @@ var IntoUnderlyingSource = class {
   }
 };
 if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
+var MetricsSnapshot = class _MetricsSnapshot {
+  static __wrap(ptr) {
+    const obj = Object.create(_MetricsSnapshot.prototype);
+    obj.__wbg_ptr = ptr;
+    MetricsSnapshotFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    MetricsSnapshotFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_metricssnapshot_free(ptr, 0);
+  }
+  /**
+   * Classified error counters keyed by error metric key.
+   * @returns {Map<any, any>}
+   */
+  get error_counters() {
+    const ret = wasm.__wbg_get_metricssnapshot_error_counters(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * Duration of the snapshot interval in fractional seconds.
+   * Exposed as `Number` (not `BigInt`) so plain JS arithmetic works.
+   * @returns {number}
+   */
+  get interval_secs() {
+    const ret = wasm.__wbg_get_metricssnapshot_interval_secs(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Operational counters and gauges (authorization, cache, JWT, data, lock).
+   * @returns {Map<any, any>}
+   */
+  get operational_stats() {
+    const ret = wasm.__wbg_get_metricssnapshot_operational_stats(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * Per-policy evaluation counts (`policy_id`, `policy_id.allow`, `policy_id.deny`).
+   * @returns {Map<any, any>}
+   */
+  get policy_stats() {
+    const ret = wasm.__wbg_get_metricssnapshot_policy_stats(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * Convert `MetricsSnapshot` to json string value.
+   *
+   * `policy_stats`, `error_counters` and `operational_stats` are converted
+   * from `Map` to plain objects so `JSON.stringify` emits their entries.
+   * @returns {string}
+   */
+  jsonString() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.metricssnapshot_jsonString(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr1 = r0;
+      var len1 = r1;
+      if (r3) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeObject(r2);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * Classified error counters keyed by error metric key.
+   * @param {Map<any, any>} arg0
+   */
+  set error_counters(arg0) {
+    wasm.__wbg_set_metricssnapshot_error_counters(this.__wbg_ptr, addHeapObject(arg0));
+  }
+  /**
+   * Duration of the snapshot interval in fractional seconds.
+   * Exposed as `Number` (not `BigInt`) so plain JS arithmetic works.
+   * @param {number} arg0
+   */
+  set interval_secs(arg0) {
+    wasm.__wbg_set_metricssnapshot_interval_secs(this.__wbg_ptr, arg0);
+  }
+  /**
+   * Operational counters and gauges (authorization, cache, JWT, data, lock).
+   * @param {Map<any, any>} arg0
+   */
+  set operational_stats(arg0) {
+    wasm.__wbg_set_metricssnapshot_operational_stats(this.__wbg_ptr, addHeapObject(arg0));
+  }
+  /**
+   * Per-policy evaluation counts (`policy_id`, `policy_id.allow`, `policy_id.deny`).
+   * @param {Map<any, any>} arg0
+   */
+  set policy_stats(arg0) {
+    wasm.__wbg_set_metricssnapshot_policy_stats(this.__wbg_ptr, addHeapObject(arg0));
+  }
+};
+if (Symbol.dispose) MetricsSnapshot.prototype[Symbol.dispose] = MetricsSnapshot.prototype.free;
 var MultiIssuerAuthorizeResult = class _MultiIssuerAuthorizeResult {
   static __wrap(ptr) {
     const obj = Object.create(_MultiIssuerAuthorizeResult.prototype);
@@ -2438,7 +2583,7 @@ function __wbg_get_imports() {
           const a = state0.a;
           state0.a = 0;
           try {
-            return __wasm_bindgen_func_elem_8962(a, state0.b, arg02, arg12);
+            return __wasm_bindgen_func_elem_8982(a, state0.b, arg02, arg12);
           } finally {
             state0.a = a;
           }
@@ -2621,6 +2766,12 @@ function __wbg_get_imports() {
       const ret = getObject(arg0).status;
       return ret;
     },
+    __wbg_stringify_54b3d9b61602aee6: function() {
+      return handleError(function(arg0) {
+        const ret = JSON.stringify(getObject(arg0));
+        return addHeapObject(ret);
+      }, arguments);
+    },
     __wbg_subarray_1daff70dde20c145: function(arg0, arg1, arg2) {
       const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
       return addHeapObject(ret);
@@ -2663,15 +2814,15 @@ function __wbg_get_imports() {
       console.warn(...getObject(arg0));
     },
     __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_8907);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_8927);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12467);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12488);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_8741);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_8761);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000004: function(arg0) {
@@ -2707,19 +2858,19 @@ function __wbg_get_imports() {
     "./cedarling_wasm_bg.js": import0
   };
 }
-function __wasm_bindgen_func_elem_8741(arg0, arg1) {
-  wasm.__wasm_bindgen_func_elem_8741(arg0, arg1);
+function __wasm_bindgen_func_elem_8761(arg0, arg1) {
+  wasm.__wasm_bindgen_func_elem_8761(arg0, arg1);
 }
-function __wasm_bindgen_func_elem_12467(arg0, arg1, arg2) {
-  wasm.__wasm_bindgen_func_elem_12467(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_12488(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_12488(arg0, arg1, addHeapObject(arg2));
 }
-function __wasm_bindgen_func_elem_8962(arg0, arg1, arg2, arg3) {
-  wasm.__wasm_bindgen_func_elem_8962(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_8982(arg0, arg1, arg2, arg3) {
+  wasm.__wasm_bindgen_func_elem_8982(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
-function __wasm_bindgen_func_elem_8907(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_8927(arg0, arg1, arg2) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-    wasm.__wasm_bindgen_func_elem_8907(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm.__wasm_bindgen_func_elem_8927(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -2777,6 +2928,9 @@ var IntoUnderlyingSinkFinalization = typeof FinalizationRegistry === "undefined"
 var IntoUnderlyingSourceFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
 } } : new FinalizationRegistry((ptr) => wasm.__wbg_intounderlyingsource_free(ptr, 1));
+var MetricsSnapshotFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_metricssnapshot_free(ptr, 1));
 var MultiIssuerAuthorizeResultFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
 } } : new FinalizationRegistry((ptr) => wasm.__wbg_multiissuerauthorizeresult_free(ptr, 1));