@voxgig/sdkgen 4.32.1 → 4.34.0

package/project/.sdk/tm/csharp/feature/DebugFeature.cs

@@ -1,9 +1,10 @@
 // Request/response capture for debugging. 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 (e.g. to
-// stream to a console). `max` caps the buffer (default 100).
+// timing - on the feature's Entries. Every entry passes through the SDK's
+// clean utility (clean.keys and every registered secret value); the
+// `redact` option ADDS header names on top of that. An optional `onEntry`
+// callback receives each finished entry (e.g. to stream to a console).
+// `max` caps the buffer (default 100).
 
 using static ProjectNameSdk.Feature.FeatureOptions;
 
@@ -19,12 +20,6 @@ public class DebugFeature : BaseFeature
 
     private const string EntryKey = "debug_entry";
 
-    private static readonly List<string> DefaultRedact = new()
-    {
-        "authorization", "cookie", "set-cookie", "api-key", "apikey",
-        "x-api-key", "idempotency-key",
-    };
-
     public DebugFeature()
     {
         Version = "0.0.1";
@@ -58,7 +53,7 @@ public class DebugFeature : BaseFeature
         {
             entry["method"] = ctx.Spec.Method;
             entry["url"] = ctx.Spec.Url != "" ? ctx.Spec.Url : ctx.Spec.Path;
-            entry["headers"] = Redact(ctx.Spec.Headers);
+            entry["headers"] = Redact(ctx, ctx.Spec.Headers);
         }
         ctx.Out[EntryKey] = entry;
     }
@@ -126,6 +121,11 @@ public class DebugFeature : BaseFeature
             entry["status"] = ctx.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 = Fclean(ctx, entry);
+
         Entries.Add(entry);
         var max = FoptInt(_options, "max", 100);
         while (Entries.Count > max)
@@ -139,19 +139,22 @@ public class DebugFeature : BaseFeature
         }
     }
 
-    private Dictionary<string, object?> Redact(Dictionary<string, object?>? headers)
+    // The core clean rules apply (clean.keys, every registered value); the
+    // feature's own `redact` list ADDS header names on top of them.
+    private Dictionary<string, object?> Redact(Context ctx, Dictionary<string, object?>? headers)
     {
         var redacted = new Dictionary<string, object?>();
         if (headers == null)
         {
             return redacted;
         }
-        var patterns = FoptStrList(_options, "redact") ?? DefaultRedact;
+        var patterns = (FoptStrList(_options, "redact") ?? new List<string>())
+            .Select(p => p.ToLowerInvariant()).ToList();
         foreach (var kv in headers)
         {
-            var masked = patterns.Any(p => kv.Key.ToLowerInvariant() == p);
-            redacted[kv.Key] = masked ? "<redacted>" : kv.Value;
+            var masked = patterns.Contains(kv.Key.ToLowerInvariant());
+            redacted[kv.Key] = masked ? "[redacted]" : kv.Value;
         }
-        return redacted;
+        return Fclean(ctx, redacted);
     }
 }

package/project/.sdk/tm/csharp/feature/FeatureOptions.cs

@@ -207,4 +207,20 @@ internal static class FeatureOptions
     {
         return int.TryParse(s.Trim(), out var n) ? n : def;
     }
+
+    // Fclean passes a record a feature is about to emit through the SDK's
+    // clean utility: every sink, buffer and logger receives the masked copy.
+    internal static Dictionary<string, object?> Fclean(Context ctx, Dictionary<string, object?> record)
+    {
+        var clean = ctx.Utility?.Clean;
+        return clean == null
+            ? record
+            : clean(ctx, record) as Dictionary<string, object?> ?? record;
+    }
+
+    internal static string FcleanStr(Context ctx, string text)
+    {
+        var clean = ctx.Utility?.Clean;
+        return clean == null ? text : clean(ctx, text) as string ?? text;
+    }
 }

package/project/.sdk/tm/csharp/feature/LogFeature.cs

@@ -104,6 +104,9 @@ public class LogFeature : BaseFeature
             attrs["spec"] = ctx.Spec.Method + " " + ctx.Spec.Path;
         }
 
-        _logger(level, "hook", attrs);
+        // A log line leaves the pipeline, so it carries the cleaned record: a
+        // path can hold a query credential, and a logger serialises whatever
+        // it is handed.
+        _logger(level, "hook", Fclean(ctx, attrs));
     }
 }

package/project/.sdk/tm/csharp/feature/ProxyFeature.cs

@@ -19,6 +19,10 @@ public class ProxyFeature : BaseFeature
     private Dictionary<string, object?>? _options;
     private List<string> _noProxy = new();
 
+    // The proxy target as configured, for routing; Url below is the cleaned
+    // form, since a proxy URL may carry credentials as userinfo.
+    private string _target = "";
+
     // Activity tracking (mirrors the ts client._proxy record).
     public int Routed;
     public string Url = "";
@@ -43,14 +47,14 @@ public class ProxyFeature : BaseFeature
             return;
         }
 
-        Url = FoptStr(_options, "url", "");
+        _target = FoptStr(_options, "url", "");
         var noProxy = FoptStrList(_options, "noProxy");
 
         if (FoptBool(_options, "fromEnv", false))
         {
-            if (Url == "")
+            if (_target == "")
             {
-                Url = FirstEnv("HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy");
+                _target = FirstEnv("HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy");
             }
             if (noProxy == null)
             {
@@ -72,6 +76,23 @@ public class ProxyFeature : BaseFeature
             }
         }
 
+        // A proxy URL may carry credentials as userinfo, from the option or
+        // the environment, and neither is under a sensitive key name.
+        if (_target != "" && Uri.TryCreate(_target, UriKind.Absolute, out var parsed) &&
+            parsed.UserInfo != "")
+        {
+            foreach (var part in parsed.UserInfo.Split(':', 2))
+            {
+                if (part != "")
+                {
+                    ctx.Utility!.CleanAdd(ctx, part);
+                    try { ctx.Utility.CleanAdd(ctx, Uri.UnescapeDataString(part)); }
+                    catch (Exception) { }
+                }
+            }
+        }
+        Url = FcleanStr(ctx, _target);
+
         var inner = ctx.Utility!.Fetcher;
 
         ctx.Utility.Fetcher = (ctx2, url, fetchdef) =>
@@ -83,14 +104,14 @@ public class ProxyFeature : BaseFeature
 
     private Dictionary<string, object?> Route(string url, Dictionary<string, object?> fetchdef)
     {
-        if (Url == "" || Bypass(url))
+        if (_target == "" || Bypass(url))
         {
             return fetchdef;
         }
 
         var routed = new Dictionary<string, object?>(fetchdef)
         {
-            ["proxy"] = Url,
+            ["proxy"] = _target,
         };
 
         Routed++;

package/project/.sdk/tm/csharp/feature/SecretsFeature.cs

@@ -194,6 +194,8 @@ public class SecretsFeature : BaseFeature
 
         if ("" != seat)
         {
+            Register(seat);
+
             string key;
             try
             {
@@ -290,6 +292,17 @@ public class SecretsFeature : BaseFeature
         return _sek;
     }
 
+    // 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 void Register(string? value)
+    {
+        var ctx = _client?.GetRootCtx();
+        if (null != value && null != ctx && null != ctx.Utility?.CleanAdd)
+        {
+            ctx.Utility.CleanAdd(ctx, value);
+        }
+    }
+
     // Credential exposes the resolved credential (empty when none) - the
     // state the transport injects. Tests and callers read it here rather
     // than from the options map, which this feature never mutates.
@@ -409,6 +422,7 @@ public class SecretsFeature : BaseFeature
         // sekreto's invariant, and the whole of this feature's fail-closed
         // behaviour rides on the difference.
         var found = _sek.TryGet(_secretname);
+        Register(found);
 
         if (null == _exchange)
         {
@@ -836,6 +850,8 @@ public class SecretsFeature : BaseFeature
                 "' field from " + url);
         }
 
+        Register(token);
+
         return token;
     }
 

package/project/.sdk/tm/csharp/feature/TelemetryFeature.cs

@@ -117,12 +117,14 @@ public class TelemetryFeature : BaseFeature
         span["durationMs"] = dur;
         span["ok"] = ok;
 
+        var finished = Fclean(ctx, span);
+
         ActiveSpans--;
-        Spans.Add(span);
+        Spans.Add(finished);
 
         if (Opt(_options, "exporter") is Action<Dictionary<string, object?>> exporter)
         {
-            exporter(span);
+            exporter(finished);
         }
     }
 

package/project/.sdk/tm/csharp/test/FeatureTest.cs

@@ -831,7 +831,7 @@ public class FeatureDebugTest
         Assert.Single(f.Entries);
         Assert.Equal(2, seen.Count);
         var headers = seen[0]["headers"] as Dictionary<string, object?>;
-        Assert.Equal("<redacted>", headers?["authorization"]);
+        Assert.Equal("[redacted]", headers?["authorization"]);
     }
 
     [Fact]
@@ -872,7 +872,7 @@ public class FeatureDebugTest
             },
         });
         var headers = f.Entries[0]["headers"] as Dictionary<string, object?>;
-        Assert.Equal("<redacted>", headers?["x-secret"]);
+        Assert.Equal("[redacted]", headers?["x-secret"]);
         Assert.Equal("show", headers?["x-ok"]);
     }