@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/tm/c/feature/debug.c

@@ -0,0 +1,230 @@
+// Request/response capture for debugging (mirrors feature/debug.rs). Records a
+// bounded ring buffer of per-operation traces — method, URL, redacted headers,
+// response status and timing — on the feature's entries. Sensitive header
+// values (matching `redact`, default authorization/cookie/api-key style names)
+// are masked. An optional `onEntry` callback receives each finished entry.
+// `max` caps the buffer (default 100).
+
+#include "sdk.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define DEBUG_ENTRY_KEY "debug_entry"
+
+static const char* DEBUG_DEFAULT_REDACT[] = {
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "api-key",
+  "apikey",
+  "x-api-key",
+  "idempotency-key",
+};
+#define DEBUG_DEFAULT_REDACT_LEN (sizeof(DEBUG_DEFAULT_REDACT) / sizeof(DEBUG_DEFAULT_REDACT[0]))
+
+typedef struct {
+  Feature base;
+  char* name;
+  bool active;
+  voxgig_value* add_opts;
+  voxgig_value* options;
+
+  // Activity tracking (mirrors the ts client._debug record).
+  voxgig_value* entries; // List of Value
+} DebugFeature;
+
+// True when lowercase(key) == pat (pat compared as-is, mirroring rust
+// `k.to_lowercase() == *p`).
+static bool eq_lower(const char* key, const char* pat) {
+  size_t i = 0;
+  for (; key[i] != '\0' && pat[i] != '\0'; i++) {
+    if ((char)tolower((unsigned char)key[i]) != pat[i]) return false;
+  }
+  return key[i] == '\0' && pat[i] == '\0';
+}
+
+// patterns = fopt_str_list(options,"redact") or DEBUG_DEFAULT_REDACT.
+static bool is_redacted(DebugFeature* df, const char* key) {
+  voxgig_value* rl = getp(df->options, "redact");
+  if (voxgig_is_list(rl)) {
+    voxgig_list* l = voxgig_as_list(rl);
+    for (size_t i = 0; i < l->len; i++) {
+      voxgig_value* pv = l->items[i];
+      if (voxgig_is_string(pv) && eq_lower(key, voxgig_as_string(pv))) return true;
+    }
+    return false;
+  }
+  for (size_t i = 0; i < DEBUG_DEFAULT_REDACT_LEN; i++) {
+    if (eq_lower(key, DEBUG_DEFAULT_REDACT[i])) return true;
+  }
+  return false;
+}
+
+static voxgig_value* debug_redact(DebugFeature* df, voxgig_value* headers) {
+  voxgig_value* out = v_map();
+  if (voxgig_is_map(headers)) {
+    voxgig_map* m = voxgig_as_map(headers);
+    for (size_t i = 0; i < m->len; i++) {
+      const char* k = m->entries[i].key;
+      if (is_redacted(df, k)) {
+        setp(out, k, v_str("<redacted>"));
+      } else {
+        setp(out, k, m->entries[i].value); // v.clone(): setp retains
+      }
+    }
+  }
+  return out;
+}
+
+static char* dot_join(const char* a, const char* b) {
+  size_t na = a ? strlen(a) : 0;
+  size_t nb = b ? strlen(b) : 0;
+  char* s = (char*)malloc(na + nb + 2);
+  memcpy(s, a ? a : "", na);
+  s[na] = '.';
+  memcpy(s + na + 1, b ? b : "", nb);
+  s[na + 1 + nb] = '\0';
+  return s;
+}
+
+static void debug_finish(DebugFeature* df, Context* ctx, bool ok) {
+  // Finish once per operation: the marker in ctx.out is consumed here.
+  voxgig_value* entry = ctx_out_extra_get(ctx, DEBUG_ENTRY_KEY);
+  if (!voxgig_is_map(entry)) {
+    return;
+  }
+  ctx_out_extra_set(ctx, DEBUG_ENTRY_KEY, v_undef()); // out_take
+
+  bool result_ok = ctx->result ? ctx->result->ok : true;
+  setp(entry, "ok", v_bool(ok && result_ok));
+
+  int64_t start = 0;
+  get_i64(entry, "start", &start); // unwrap_or(0)
+  int64_t dur = fopt_now_call(df->options) - start;
+  if (dur < 0) dur = 0;
+  setp(entry, "durationMs", v_num((double)dur));
+
+  if (v_is_noval(getp(entry, "status"))) {
+    if (ctx->result) {
+      setp(entry, "status", v_num((double)ctx->result->status));
+    }
+  }
+
+  voxgig_list_push(voxgig_as_list(df->entries), voxgig_retain(entry));
+  int64_t max = fopt_int(df->options, "max", 100);
+  while (voxgig_list_len(voxgig_as_list(df->entries)) > (size_t)max) {
+    voxgig_list_erase(voxgig_as_list(df->entries), 0);
+  }
+
+  voxgig_value* on_entry = getp(df->options, "onEntry");
+  if (voxgig_is_func(on_entry)) {
+    call_vfn(on_entry, entry);
+  }
+}
+
+static void debug_pre_request(DebugFeature* df, Context* ctx) {
+  if (!df->active) {
+    return;
+  }
+
+  const char* entity = ctx->op->entity;
+  const char* opname = ctx->op->name;
+
+  voxgig_value* entry = v_map();
+  char* op = dot_join(entity, opname);
+  setp(entry, "op", v_str(op));
+  setp(entry, "start", v_num((double)fopt_now_call(df->options)));
+  if (ctx->spec) {
+    Spec* s = ctx->spec;
+    setp(entry, "method", v_str(s->method ? s->method : ""));
+    if (s->url && s->url[0] != '\0') {
+      setp(entry, "url", v_str(s->url));
+    } else {
+      setp(entry, "url", v_str(s->path ? s->path : ""));
+    }
+    setp(entry, "headers", debug_redact(df, s->headers));
+  }
+  ctx_out_extra_set(ctx, DEBUG_ENTRY_KEY, entry);
+}
+
+static void debug_pre_response(DebugFeature* df, Context* ctx) {
+  if (!df->active) {
+    return;
+  }
+
+  voxgig_value* entry = ctx_out_extra_get(ctx, DEBUG_ENTRY_KEY);
+  if (!voxgig_is_map(entry)) {
+    return;
+  }
+  if (ctx->response) {
+    setp(entry, "status", v_num((double)ctx->response->status));
+    const char* url = get_str(entry, "url");
+    if (!url || url[0] == '\0') {
+      if (ctx->spec) {
+        setp(entry, "url", v_str(ctx->spec->url ? ctx->spec->url : ""));
+      }
+    }
+  }
+}
+
+static void debug_pre_done(DebugFeature* df, Context* ctx) {
+  debug_finish(df, ctx, true);
+}
+
+static void debug_pre_unexpected(DebugFeature* df, Context* ctx) {
+  voxgig_value* entry = ctx_out_extra_get(ctx, DEBUG_ENTRY_KEY);
+  if (voxgig_is_map(entry)) {
+    if (ctx->ctrl && ctx->ctrl->err) {
+      setp(entry, "error", v_str(ctx->ctrl->err->msg ? ctx->ctrl->err->msg : ""));
+    }
+  }
+  debug_finish(df, ctx, false);
+}
+
+static const char* debug_name(Feature* f) { return ((DebugFeature*)f)->name; }
+static bool debug_active(Feature* f) { return ((DebugFeature*)f)->active; }
+static voxgig_value* debug_add_options(Feature* f) { return ((DebugFeature*)f)->add_opts; }
+
+static void debug_init(Feature* f, Context* ctx, voxgig_value* options) {
+  (void)ctx;
+  DebugFeature* df = (DebugFeature*)f;
+  df->options = options;
+  df->active = fopt_bool(options, "active", false);
+}
+
+static void debug_hook(Feature* f, const char* name, Context* ctx) {
+  DebugFeature* df = (DebugFeature*)f;
+  if (strcmp(name, "PreRequest") == 0) {
+    debug_pre_request(df, ctx);
+  } else if (strcmp(name, "PreResponse") == 0) {
+    debug_pre_response(df, ctx);
+  } else if (strcmp(name, "PreDone") == 0) {
+    debug_pre_done(df, ctx);
+  } else if (strcmp(name, "PreUnexpected") == 0) {
+    debug_pre_unexpected(df, ctx);
+  }
+}
+
+static voxgig_value* debug_track(Feature* f) {
+  DebugFeature* df = (DebugFeature*)f;
+  int64_t n = (int64_t)voxgig_list_len(voxgig_as_list(df->entries));
+  return cmap(1, "entries", v_num((double)n));
+}
+
+static const FeatureVT DEBUG_VT = {
+  debug_name, debug_active, debug_add_options, debug_init, debug_hook,
+  debug_track,
+};
+
+Feature* feature_debug_new(void) {
+  DebugFeature* df = (DebugFeature*)calloc(1, sizeof(DebugFeature));
+  df->base.vt = &DEBUG_VT;
+  df->name = strdup("debug");
+  df->active = true;
+  df->add_opts = NULL;
+  df->options = voxgig_new_undef();
+  df->entries = voxgig_new_list();
+  return (Feature*)df;
+}

package/project/.sdk/tm/c/feature/idempotency.c

@@ -0,0 +1,164 @@
+// Idempotency keys for mutating operations (mirrors feature/idempotency.rs).
+// Adds an `Idempotency-Key` header (name configurable via `header`) to unsafe
+// requests so a server can de-duplicate retried writes. The key is set once,
+// at PreRequest, before the request is built — so it is stable across
+// transport-level retries of the same call. A caller-supplied header is never
+// overwritten (case-insensitive). The key generator is injectable (`keygen`).
+
+#include "sdk.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  Feature base;
+  char* name;
+  bool active;
+  voxgig_value* add_opts;
+  voxgig_value* options;
+
+  // Activity tracking (mirrors the ts client._idempotency record).
+  int64_t issued;
+  char* last;
+} IdempotencyFeature;
+
+// ---- local string helpers -------------------------------------------------
+
+static char* str_upper(const char* s) {
+  size_t n = strlen(s);
+  char* r = (char*)malloc(n + 1);
+  for (size_t i = 0; i < n; i++) r[i] = (char)toupper((unsigned char)s[i]);
+  r[n] = '\0';
+  return r;
+}
+
+// Mirrors fopt_str_list(options,key).unwrap_or_else(defaults) followed by an
+// `any(...)` membership test: when the option is a list, only its string
+// elements are considered (defaults ignored); otherwise the defaults apply.
+// Comparison is case-insensitive when `ci`.
+static bool option_list_match(voxgig_value* options, const char* key,
+                              const char* needle, const char** defaults,
+                              size_t ndefaults, bool ci) {
+  voxgig_value* lst = getp(options, key);
+  if (voxgig_is_list(lst)) {
+    voxgig_list* l = voxgig_as_list(lst);
+    for (size_t i = 0; i < l->len; i++) {
+      voxgig_value* item = l->items[i];
+      if (voxgig_is_string(item)) {
+        const char* s = voxgig_as_string(item);
+        if (ci ? (strcasecmp(s, needle) == 0) : (strcmp(s, needle) == 0)) return true;
+      }
+    }
+    return false;
+  }
+  for (size_t i = 0; i < ndefaults; i++) {
+    if (ci ? (strcasecmp(defaults[i], needle) == 0) : (strcmp(defaults[i], needle) == 0))
+      return true;
+  }
+  return false;
+}
+
+static bool idem_mutating(IdempotencyFeature* f, Context* ctx) {
+  char* method = str_upper((ctx->spec && ctx->spec->method) ? ctx->spec->method : "");
+
+  static const char* MDEF[] = {"POST", "PUT", "PATCH", "DELETE"};
+  bool result;
+  if (method[0] != '\0' &&
+      option_list_match(f->options, "methods", method, MDEF, 4, true)) {
+    result = true;
+  } else {
+    const char* opname = (ctx->op && ctx->op->name) ? ctx->op->name : "";
+    static const char* ODEF[] = {"create", "update", "remove"};
+    result = option_list_match(f->options, "ops", opname, ODEF, 3, false);
+  }
+
+  free(method);
+  return result;
+}
+
+// genkey returns a malloc'd key string. Uses the injectable `keygen` when it
+// is a Func returning a string, else a random 24-hex-digit key.
+static char* idem_genkey(IdempotencyFeature* f) {
+  voxgig_value* keygen = getp(f->options, "keygen");
+  if (voxgig_is_func(keygen)) {
+    voxgig_value* r = call_vfn(keygen, voxgig_new_undef());
+    if (voxgig_is_string(r)) return strdup(voxgig_as_string(r));
+  }
+
+  char buf[32];
+  snprintf(buf, sizeof(buf), "%06llx%06llx%06llx%06llx",
+           (unsigned long long)rand_int(0x1000000),
+           (unsigned long long)rand_int(0x1000000),
+           (unsigned long long)rand_int(0x1000000),
+           (unsigned long long)rand_int(0x1000000));
+  buf[24] = '\0'; // key[..24]
+  return strdup(buf);
+}
+
+static void idem_pre_request(IdempotencyFeature* f, Context* ctx) {
+  if (!f->active) return;
+  if (!ctx->spec) return; // spec None => nothing to do
+
+  if (!idem_mutating(f, ctx)) return;
+
+  const char* header = fopt_str(f->options, "header", "Idempotency-Key");
+
+  voxgig_value* headers = ctx->spec->headers;
+  if (!voxgig_is_map(headers)) {
+    headers = voxgig_new_map();
+    ctx->spec->headers = headers;
+  }
+
+  // Respect a key the caller already provided.
+  voxgig_value* existing = fheader_get(headers, header);
+  if (!v_is_noval(existing)) return;
+
+  char* key = idem_genkey(f);
+  setp(headers, header, v_str(key));
+
+  f->issued += 1;
+  free(f->last);
+  f->last = key;
+}
+
+static const char* idem_name(Feature* f) { return ((IdempotencyFeature*)f)->name; }
+static bool idem_active(Feature* f) { return ((IdempotencyFeature*)f)->active; }
+static voxgig_value* idem_add_options(Feature* f) { return ((IdempotencyFeature*)f)->add_opts; }
+
+static void idem_init(Feature* f, Context* ctx, voxgig_value* options) {
+  (void)ctx;
+  IdempotencyFeature* idf = (IdempotencyFeature*)f;
+  idf->options = options;
+  idf->active = fopt_bool(options, "active", false);
+}
+
+static void idem_hook(Feature* f, const char* name, Context* ctx) {
+  if (strcmp(name, "PreRequest") == 0) {
+    idem_pre_request((IdempotencyFeature*)f, ctx);
+  }
+}
+
+static voxgig_value* idem_track(Feature* f) {
+  IdempotencyFeature* idf = (IdempotencyFeature*)f;
+  return cmap(2, "issued", v_num((double)idf->issued),
+              "last", v_str(idf->last ? idf->last : ""));
+}
+
+static const FeatureVT IDEMPOTENCY_VT = {
+  idem_name, idem_active, idem_add_options, idem_init, idem_hook,
+  idem_track,
+};
+
+Feature* feature_idempotency_new(void) {
+  IdempotencyFeature* idf = (IdempotencyFeature*)calloc(1, sizeof(IdempotencyFeature));
+  idf->base.vt = &IDEMPOTENCY_VT;
+  idf->name = strdup("idempotency");
+  idf->active = true; // matches rust default (overridden by init from options)
+  idf->add_opts = NULL;
+  idf->options = voxgig_new_undef();
+  idf->issued = 0;
+  idf->last = NULL; // rust String::new()
+  return (Feature*)idf;
+}

package/project/.sdk/tm/c/feature/log.c

@@ -0,0 +1,79 @@
+// Structured hook logging (mirrors feature/log.rs), stderr lines. Logs every
+// pipeline hook with operation + spec summary when active; `level` filters.
+
+#include "sdk.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  Feature base;
+  char* name;
+  bool active;
+  voxgig_value* add_opts;
+  voxgig_value* options;
+  int64_t level;
+} LogFeature;
+
+static int64_t level_num(const char* level) {
+  if (strcmp(level, "debug") == 0) return 10;
+  if (strcmp(level, "warn") == 0) return 30;
+  if (strcmp(level, "error") == 0) return 40;
+  return 20; // info
+}
+
+static const char* log_name(Feature* f) { return ((LogFeature*)f)->name; }
+static bool log_active(Feature* f) { return ((LogFeature*)f)->active; }
+static voxgig_value* log_add_options(Feature* f) { return ((LogFeature*)f)->add_opts; }
+
+static void log_init(Feature* f, Context* ctx, voxgig_value* options) {
+  (void)ctx;
+  LogFeature* lf = (LogFeature*)f;
+  lf->options = options;
+  lf->active = fopt_bool(options, "active", false);
+  lf->level = level_num(fopt_str(options, "level", "info"));
+}
+
+static void loghook(LogFeature* lf, const char* hook, Context* ctx) {
+  if (!lf->active) return;
+  if (level_num("info") < lf->level) return;
+
+  const char* opname = ctx->op->name;
+  char specinfo[256];
+  specinfo[0] = '\0';
+  if (ctx->spec) {
+    snprintf(specinfo, sizeof(specinfo), "%s %s", ctx->spec->method, ctx->spec->path);
+  }
+  fprintf(stderr, "name=log hook=%s op=%s spec=%s\n", hook, opname, specinfo);
+}
+
+static void log_hook(Feature* f, const char* name, Context* ctx) {
+  LogFeature* lf = (LogFeature*)f;
+  static const char* HOOKS[] = {
+    "PostConstruct", "PostConstructEntity", "SetData", "GetData", "SetMatch",
+    "GetMatch", "PrePoint", "PreSpec", "PreRequest", "PreResponse", "PreResult", NULL,
+  };
+  for (int i = 0; HOOKS[i]; i++) {
+    if (strcmp(HOOKS[i], name) == 0) {
+      loghook(lf, name, ctx);
+      return;
+    }
+  }
+}
+
+static const FeatureVT LOG_VT = {
+  log_name, log_active, log_add_options, log_init, log_hook,
+  NULL, // no activity tracking
+};
+
+Feature* feature_log_new(void) {
+  LogFeature* lf = (LogFeature*)calloc(1, sizeof(LogFeature));
+  lf->base.vt = &LOG_VT;
+  lf->name = strdup("log");
+  lf->active = false;
+  lf->add_opts = NULL;
+  lf->options = voxgig_new_undef();
+  lf->level = level_num("info");
+  return (Feature*)lf;
+}

package/project/.sdk/tm/c/feature/metrics.c

@@ -0,0 +1,177 @@
+// Statistics capture (mirrors feature/metrics.rs). Records per-operation
+// counters and latency for every call: totals plus a breakdown keyed by
+// `<entity>.<op>`. Timing starts at endpoint resolution (PrePoint) and stops
+// when the call returns (PreDone) or fails (PreUnexpected); each operation is
+// recorded exactly once (the per-context start marker in ctx.out is consumed
+// on record). The clock is injectable (`now`) for deterministic tests.
+
+#include "sdk.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#define METRICS_START_KEY "metrics_start"
+
+typedef struct {
+  int64_t count;
+  int64_t ok;
+  int64_t err;
+  int64_t total_ms;
+  int64_t max_ms;
+} MetricsBucket;
+
+typedef struct {
+  Feature base;
+  char* name;
+  bool active;
+  voxgig_value* add_opts;
+  voxgig_value* options;
+
+  // Aggregates (mirrors the ts client._metrics record).
+  MetricsBucket total;
+  // ops HashMap<String, MetricsBucket> as parallel growable arrays.
+  char** op_keys;
+  MetricsBucket* op_buckets;
+  size_t ops_len;
+  size_t ops_cap;
+} MetricsFeature;
+
+static void bump(MetricsBucket* bucket, bool ok, int64_t dur) {
+  bucket->count += 1;
+  if (ok) {
+    bucket->ok += 1;
+  } else {
+    bucket->err += 1;
+  }
+  bucket->total_ms += dur;
+  if (dur > bucket->max_ms) {
+    bucket->max_ms = dur;
+  }
+}
+
+// ops.entry(key).or_default(): find or insert a zeroed bucket for key.
+static MetricsBucket* ops_entry(MetricsFeature* mf, const char* key) {
+  for (size_t i = 0; i < mf->ops_len; i++) {
+    if (strcmp(mf->op_keys[i], key) == 0) return &mf->op_buckets[i];
+  }
+  if (mf->ops_len == mf->ops_cap) {
+    size_t nc = mf->ops_cap ? mf->ops_cap * 2 : 8;
+    mf->op_keys = (char**)realloc(mf->op_keys, nc * sizeof(char*));
+    mf->op_buckets = (MetricsBucket*)realloc(mf->op_buckets, nc * sizeof(MetricsBucket));
+    mf->ops_cap = nc;
+  }
+  mf->op_keys[mf->ops_len] = strdup(key);
+  memset(&mf->op_buckets[mf->ops_len], 0, sizeof(MetricsBucket));
+  return &mf->op_buckets[mf->ops_len++];
+}
+
+static char* dot_join(const char* a, const char* b) {
+  size_t na = a ? strlen(a) : 0;
+  size_t nb = b ? strlen(b) : 0;
+  char* s = (char*)malloc(na + nb + 2);
+  memcpy(s, a ? a : "", na);
+  s[na] = '.';
+  memcpy(s + na + 1, b ? b : "", nb);
+  s[na + 1 + nb] = '\0';
+  return s;
+}
+
+static void metrics_record(MetricsFeature* mf, Context* ctx, bool ok) {
+  // Record once per operation: the missing start marker makes a second call
+  // (PreDone followed by PreUnexpected on failure) a no-op.
+  voxgig_value* start_v = ctx_out_extra_get(ctx, METRICS_START_KEY);
+  if (!voxgig_is_number(start_v)) {
+    // "other" branch: put anything unexpected back (a no-op here) and return.
+    return;
+  }
+  int64_t start = to_int(start_v);
+  // Consume the marker.
+  ctx_out_extra_set(ctx, METRICS_START_KEY, v_undef());
+
+  int64_t dur = fopt_now_call(mf->options) - start;
+  if (dur < 0) dur = 0;
+
+  const char* entity = ctx->op->entity;
+  const char* opname = ctx->op->name;
+  char* key = dot_join(entity, opname);
+
+  bump(&mf->total, ok, dur);
+  bump(ops_entry(mf, key), ok, dur);
+}
+
+static void metrics_pre_point(MetricsFeature* mf, Context* ctx) {
+  if (!mf->active) {
+    return;
+  }
+  ctx_out_extra_set(ctx, METRICS_START_KEY, v_num((double)fopt_now_call(mf->options)));
+}
+
+static void metrics_pre_done(MetricsFeature* mf, Context* ctx) {
+  // Classify by the actual result: a 4xx/5xx that flows through still reaches
+  // PreDone before the pipeline errors.
+  bool ok = ctx->result ? (ctx->result->ok && ctx->result->err == NULL) : false;
+  metrics_record(mf, ctx, ok);
+}
+
+static void metrics_pre_unexpected(MetricsFeature* mf, Context* ctx) {
+  metrics_record(mf, ctx, false);
+}
+
+static const char* metrics_name(Feature* f) { return ((MetricsFeature*)f)->name; }
+static bool metrics_active(Feature* f) { return ((MetricsFeature*)f)->active; }
+static voxgig_value* metrics_add_options(Feature* f) { return ((MetricsFeature*)f)->add_opts; }
+
+static void metrics_init(Feature* f, Context* ctx, voxgig_value* options) {
+  (void)ctx;
+  MetricsFeature* mf = (MetricsFeature*)f;
+  mf->options = options;
+  mf->active = fopt_bool(options, "active", false);
+  memset(&mf->total, 0, sizeof(MetricsBucket));
+  mf->ops_len = 0; // reset to an empty HashMap
+}
+
+static void metrics_hook(Feature* f, const char* name, Context* ctx) {
+  MetricsFeature* mf = (MetricsFeature*)f;
+  if (strcmp(name, "PrePoint") == 0) {
+    metrics_pre_point(mf, ctx);
+  } else if (strcmp(name, "PreDone") == 0) {
+    metrics_pre_done(mf, ctx);
+  } else if (strcmp(name, "PreUnexpected") == 0) {
+    metrics_pre_unexpected(mf, ctx);
+  }
+}
+
+static voxgig_value* bucket_value(const MetricsBucket* b) {
+  return cmap(5, "count", v_num((double)b->count), "ok", v_num((double)b->ok),
+              "err", v_num((double)b->err), "totalMs", v_num((double)b->total_ms),
+              "maxMs", v_num((double)b->max_ms));
+}
+
+static voxgig_value* metrics_track(Feature* f) {
+  MetricsFeature* mf = (MetricsFeature*)f;
+  voxgig_value* ops = v_map();
+  for (size_t i = 0; i < mf->ops_len; i++) {
+    setp(ops, mf->op_keys[i], bucket_value(&mf->op_buckets[i]));
+  }
+  return cmap(2, "total", bucket_value(&mf->total), "ops", ops);
+}
+
+static const FeatureVT METRICS_VT = {
+  metrics_name, metrics_active, metrics_add_options, metrics_init, metrics_hook,
+  metrics_track,
+};
+
+Feature* feature_metrics_new(void) {
+  MetricsFeature* mf = (MetricsFeature*)calloc(1, sizeof(MetricsFeature));
+  mf->base.vt = &METRICS_VT;
+  mf->name = strdup("metrics");
+  mf->active = true;
+  mf->add_opts = NULL;
+  mf->options = voxgig_new_undef();
+  memset(&mf->total, 0, sizeof(MetricsBucket));
+  mf->op_keys = NULL;
+  mf->op_buckets = NULL;
+  mf->ops_len = 0;
+  mf->ops_cap = 0;
+  return (Feature*)mf;
+}