@voxgig/sdkgen 4.32.0 → 4.33.0

package/project/.sdk/tm/kotlin/feature/AuditFeature.kt

@@ -3,6 +3,7 @@ package KOTLINPACKAGE.feature
 import java.util.function.Consumer
 
 import KOTLINPACKAGE.core.Context
+import KOTLINPACKAGE.core.Helpers
 import KOTLINPACKAGE.core.SdkClient
 
 // Audit trail. Emits a structured record for every operation — who (actor),
@@ -65,18 +66,19 @@ class AuditFeature : BaseFeature("audit", "0.0.1", true) {
     val entity = ctx.op.entity
     val opname = ctx.op.name
 
-    val record = linkedMapOf<String, Any?>()
-    record["seq"] = this.seq
-    record["ts"] = FeatureOptions.foptNow(this.options).getAsLong()
-    record["actor"] = actor
-    record["entity"] = entity
-    record["op"] = opname
-    record["outcome"] = outcome
-    record["correlationId"] = ctx.id
+    val raw = linkedMapOf<String, Any?>()
+    raw["seq"] = this.seq
+    raw["ts"] = FeatureOptions.foptNow(this.options).getAsLong()
+    raw["actor"] = actor
+    raw["entity"] = entity
+    raw["op"] = opname
+    raw["outcome"] = outcome
+    raw["correlationId"] = ctx.id
     val result = ctx.result
     if (result != null) {
-      record["status"] = result.status
+      raw["status"] = result.status
     }
+    val record = Helpers.toMapAny(ctx.utility?.clean?.invoke(ctx, raw)) ?: raw
 
     this.records.add(record)
     val max = FeatureOptions.foptInt(this.options, "max", 1000)

package/project/.sdk/tm/kotlin/feature/CostFeature.kt

@@ -297,15 +297,18 @@ class CostFeature : BaseFeature("cost", "0.0.1", true) {
     bump(this.ops, "$entity.$opname", amount)
     bump(this.actors, actor, amount)
 
+    // The record leaves through `last` and the sink, so its text is cleaned.
+    val cs = { s: String -> ctx.utility?.clean?.invoke(ctx, s)?.toString() ?: s }
+
     this.seq++
     val record = CostRecord()
     record.seq = this.seq
-    record.entity = entity
-    record.op = opname
-    record.actor = actor
+    record.entity = cs(entity)
+    record.op = cs(opname)
+    record.actor = cs(actor)
     record.amount = amount
-    record.currency = this.currency
-    record.source = source
+    record.currency = cs(this.currency)
+    record.source = cs(source)
     record.attempts = pending.attempts
     this.last = record
 

package/project/.sdk/tm/kotlin/feature/DebugFeature.kt

@@ -43,7 +43,7 @@ class DebugFeature : BaseFeature("debug", "0.0.1", true) {
       } else {
         entry["url"] = spec.path
       }
-      entry["headers"] = redact(spec.headers)
+      entry["headers"] = redact(ctx, spec.headers)
     }
     ctx.out[DEBUG_ENTRY_KEY] = entry
   }
@@ -77,7 +77,7 @@ class DebugFeature : BaseFeature("debug", "0.0.1", true) {
   }
 
   private fun finish(ctx: Context, ok: Boolean) {
-    val entry = Helpers.toMapAny(ctx.out[DEBUG_ENTRY_KEY]) ?: return
+    var entry = Helpers.toMapAny(ctx.out[DEBUG_ENTRY_KEY]) ?: return
     ctx.out.remove(DEBUG_ENTRY_KEY)
 
     val result = ctx.result
@@ -92,6 +92,11 @@ class DebugFeature : BaseFeature("debug", "0.0.1", true) {
       entry["status"] = result.status
     }
 
+    // The whole entry leaves through the buffer and the callback: the url
+    // and the error message can carry a query credential the header mask
+    // above never saw.
+    entry = Helpers.toMapAny(ctx.utility?.clean?.invoke(ctx, entry)) ?: entry
+
     this.entries.add(entry)
     val max = FeatureOptions.foptInt(this.options, "max", 100)
     while (this.entries.size > max) {
@@ -104,38 +109,26 @@ class DebugFeature : BaseFeature("debug", "0.0.1", true) {
     }
   }
 
-  private fun redact(headers: MutableMap<String, Any?>?): MutableMap<String, Any?> {
+  // The core clean rules apply (clean.keys, every registered value); the
+  // feature's own `redact` list ADDS header names on top of them.
+  private fun redact(ctx: Context, headers: MutableMap<String, Any?>?): MutableMap<String, Any?> {
     val out = linkedMapOf<String, Any?>()
     if (headers == null) {
       return out
     }
-    var patterns: List<String>? = FeatureOptions.foptStrList(this.options, "redact")
-    if (patterns == null) {
-      patterns = DEFAULT_REDACT
-    }
+    val patterns = (FeatureOptions.foptStrList(this.options, "redact") ?: mutableListOf())
+      .map { it.lowercase() }
     for (h in headers.entries) {
-      var masked = false
-      for (p in patterns) {
-        if (h.key.lowercase() == p) {
-          masked = true
-          break
-        }
-      }
-      if (masked) {
-        out[h.key] = "<redacted>"
+      if (patterns.contains(h.key.lowercase())) {
+        out[h.key] = "[redacted]"
       } else {
         out[h.key] = h.value
       }
     }
-    return out
+    return Helpers.toMapAny(ctx.utility?.clean?.invoke(ctx, out)) ?: out
   }
 
   companion object {
     private const val DEBUG_ENTRY_KEY = "debug_entry"
-
-    private val DEFAULT_REDACT: List<String> = listOf(
-      "authorization", "cookie", "set-cookie", "api-key", "apikey",
-      "x-api-key", "idempotency-key",
-    )
   }
 }

package/project/.sdk/tm/kotlin/feature/LogFeature.kt

@@ -82,11 +82,15 @@ class LogFeature : BaseFeature("log", "0.0.1", true) {
       msg.append(" spec=").append(spec.method).append(" ").append(spec.path)
     }
 
+    // A log line leaves the pipeline, so it carries the cleaned text.
+    val u = ctx.utility
+    val line = if (u == null) msg.toString() else u.clean(ctx, msg.toString()).toString()
+
     when (level) {
-      "debug" -> logger.fine(msg.toString())
-      "warn" -> logger.warning(msg.toString())
-      "error" -> logger.severe(msg.toString())
-      else -> logger.info(msg.toString())
+      "debug" -> logger.fine(line)
+      "warn" -> logger.warning(line)
+      "error" -> logger.severe(line)
+      else -> logger.info(line)
     }
   }
 }

package/project/.sdk/tm/kotlin/feature/ProxyFeature.kt

@@ -1,5 +1,6 @@
 package KOTLINPACKAGE.feature
 
+import java.net.URI
 import java.util.regex.Pattern
 
 import KOTLINPACKAGE.core.Context
@@ -20,6 +21,8 @@ class ProxyFeature : BaseFeature("proxy", "0.0.1", true) {
   var routed = 0
   var url = ""
 
+  private var target = ""
+
   override fun init(ctx: Context, options: MutableMap<String, Any?>) {
     this.client = ctx.client
     this.options = options
@@ -54,18 +57,39 @@ class ProxyFeature : BaseFeature("proxy", "0.0.1", true) {
       }
     }
 
+    // A proxy URL may carry credentials as userinfo, from the option or the
+    // environment, and neither is under a sensitive key name. The transport
+    // is handed the raw target; the activity record shows the cleaned one.
+    this.target = this.url
+    if ("" != this.url) {
+      try {
+        val parsed = URI(this.url)
+        for (info in listOf(parsed.rawUserInfo, parsed.userInfo)) {
+          if (info != null && "" != info) {
+            for (part in info.split(":", limit = 2)) {
+              if ("" != part) {
+                ctx.utility!!.cleanAdd(ctx, part)
+              }
+            }
+          }
+        }
+      } catch (e: RuntimeException) {
+      }
+      this.url = ctx.utility!!.clean(ctx, this.url).toString()
+    }
+
     val inner: FetcherFn = ctx.utility!!.fetcher
 
     ctx.utility!!.fetcher = { ctx2, u, fetchdef -> inner(ctx2, u, route(u, fetchdef)) }
   }
 
   private fun route(u: String, fetchdef: MutableMap<String, Any?>): MutableMap<String, Any?> {
-    if ("" == this.url || bypass(u)) {
+    if ("" == this.target || bypass(u)) {
       return fetchdef
     }
 
     val out = LinkedHashMap(fetchdef)
-    out["proxy"] = this.url
+    out["proxy"] = this.target
 
     this.routed++
     return out

package/project/.sdk/tm/kotlin/feature/SecretsFeature.kt

@@ -78,6 +78,13 @@ import KOTLINPACKAGE.utility.struct.Struct
 class SecretsFeature : BaseFeature("secrets", "0.1.0", true) {
 
   private var client: SdkClient? = null
+
+  // Every value this feature resolves or buys is a secret the SDK handles,
+  // and none arrives under an option key the intake registration saw.
+  private fun register(value: Any?) {
+    val ctx = this.client?.getRootCtx() ?: return
+    ctx.utility?.cleanAdd?.invoke(ctx, value)
+  }
   private var fopts: MutableMap<String, Any?>? = null
 
   // The LIVE options map (the root context's options - the same instance
@@ -205,6 +212,7 @@ class SecretsFeature : BaseFeature("secrets", "0.1.0", true) {
     val providers = mutableListOf<Any?>()
 
     if ("" != explicit) {
+      register(explicit)
       try {
         providers.add(ProviderSpec(
           kind = "memory",
@@ -354,6 +362,7 @@ class SecretsFeature : BaseFeature("secrets", "0.1.0", true) {
     // A provider ERROR throws out of here and fails the op (via the
     // transport gate); only a MISS (null) falls through.
     val found = s.tryget(this.secretname)
+    register(found)
 
     if (null == this.exchange) {
       this.lock.withLock {
@@ -551,6 +560,7 @@ class SecretsFeature : BaseFeature("secrets", "0.1.0", true) {
     // required server variable, for the same reason.
     if ("live" != this.client!!.mode) {
       val token = "test-" + this.exchange!!.response
+      register(token)
       this.lock.withLock { this.cred = token }
       return token
     }
@@ -588,6 +598,7 @@ class SecretsFeature : BaseFeature("secrets", "0.1.0", true) {
     var err: RuntimeException? = null
     try {
       token = buyonce()
+      register(token)
     } catch (e: RuntimeException) {
       err = e
     } catch (e: Exception) {

package/project/.sdk/tm/kotlin/feature/TelemetryFeature.kt

@@ -88,12 +88,14 @@ class TelemetryFeature : BaseFeature("telemetry", "0.0.1", true) {
     span["durationMs"] = dur
     span["ok"] = ok
 
+    val out = Helpers.toMapAny(ctx.utility?.clean?.invoke(ctx, span)) ?: span
+
     this.activeSpans--
-    this.spans.add(span)
+    this.spans.add(out)
 
     val exporter = this.options?.get("exporter")
     if (exporter is Consumer<*>) {
-      (exporter as Consumer<MutableMap<String, Any?>>).accept(span)
+      (exporter as Consumer<MutableMap<String, Any?>>).accept(out)
     }
   }
 

package/project/.sdk/tm/kotlin/test/FeatureTest.kt

@@ -625,7 +625,7 @@ class FeatureTest {
     assertEquals(1, f.entries.size, "expected ring buffer capped at 1")
     assertEquals(2, seen.size, "expected onEntry for both ops")
     val headers = seen[0]["headers"] as MutableMap<String, Any?>
-    assertEquals("<redacted>", headers["authorization"], "expected redacted authorization")
+    assertEquals("[redacted]", headers["authorization"], "expected redacted authorization")
   }
 
   @Test
@@ -651,7 +651,7 @@ class FeatureTest {
     val h = fhMake(null, fhF(f, fhMap("now", nowFn(clock), "redact", redact)))
     h.op(fhOp("load").headers(fhMap("x-secret", "hide", "x-ok", "show")))
     val headers = f.entries[0]["headers"] as MutableMap<String, Any?>
-    assertEquals("<redacted>", headers["x-secret"], "expected x-secret redacted")
+    assertEquals("[redacted]", headers["x-secret"], "expected x-secret redacted")
     assertEquals("show", headers["x-ok"], "expected x-ok kept")
   }