Skip to content
← Todas las publicaciones
· Delta1 Labs SerilogNebula

Qué le hace el renombrado a tu salida de Serilog

Ofusca una aplicación que registra con Serilog y tus eventos estructurados pueden pasar silenciosamente de { CustomerName, Total } a { b, c } — pero solo en uno de dos caminos de código. Este artículo muestra por qué desestructurar un objeto con {@Order} refleja los nombres de propiedad vivos (que el renombrado reescribe) mientras que el {Order} de un record y los tokens explícitos de la plantilla del mensaje son literales fijados que sobreviven, y luego acota Nebula.NET para mantener registros legibles sin desofuscar tu lógica.

Ofuscas una aplicación de escritorio, la publicas y los registros estructurados que sube para soporte empiezan a volver ilegibles — no ausentes, no malformados, solo llenos de { "b": "Dana Okafor", "c": 49.90 } donde la versión anterior decía { "CustomerName": "...", "Total": ... }. Nada lanzó una excepción. Serilog funcionó exactamente igual que antes. Los nombres de las propiedades cambiaron, porque una de las dos formas en que le entregas un objeto a Serilog lee esos nombres en tiempo de ejecución, y el renombrado es precisamente lo que los reescribe.

La pregunta real

Serilog nunca ve tu código fuente. Ve una cadena de plantilla de mensaje y algunos valores de argumento, y los convierte en un conjunto de propiedades con nombre. Así que la pregunta para una compilación ofuscada es la de siempre: ¿qué nombres de propiedad capturó Serilog como texto literal que viaja intacto en tu ensamblado, y cuáles capturó reflejando sobre metadatos vivos que el renombrado ha reescrito? Si aciertas en esa distinción, tus registros siguen siendo legibles a través de la ofuscación. Si fallas, tus eventos estructurados se renombran silenciosamente a sí mismos.

Dos valores, dos caminos de código

Toma un registro de pago trivial sobre un record.

public record Order(string CustomerName, decimal Total, int Items);

var order = new Order("Dana Okafor", 49.90m, 3);

Log.Information("Checkout for {Order}", order);   // scalar path
Log.Information("Checkout for {@Order}", order);  // destructure path

La única diferencia es el @. Serilog analiza cada plantilla y, para el token llamado Order, registra una pista de captura: la primera es Destructuring.Default (tratar como escalar), la segunda es Destructuring.Destructure. Esa pista decide el camino.

El camino escalar, dentro del PropertyValueConverter de Serilog, desemboca en un ScalarValue construido a partir de order.ToString(). Para un record de C#, ToString() lo genera el compilador, y se genera para escribir el nombre de cada miembro como cadena literal:

// Order.PrintMembers, decompiled
builder.Append("CustomerName = ");
builder.Append((object)CustomerName);
builder.Append(", Total = ");
builder.Append(Total.ToString());
builder.Append(", Items = ");
builder.Append(Items.ToString());

Esas cadenas "CustomerName = " son cargas ldstr en el montículo #US. Renombra la propiedad CustomerName a b y este método sigue imprimiendo CustomerName = …, porque el texto se congeló en tiempo de compilación y ya no tiene nada que ver con el nombre de metadatos de la propiedad. La línea de registro escalar sobrevive intacta al renombrado.

El camino de desestructuración no llama a ToString(). Recorre el objeto:

// Serilog.Capturing — the shape of what destructuring does
var props = type.GetPropertiesRecursive();           // public, readable instance
var members = new List<LogEventProperty>(props.Length);
foreach (var pi in props)
    members.Add(new LogEventProperty(pi.Name, Convert(pi.GetValue(value))));
return new StructureValue(members, type.Name);

Cada propiedad capturada se nombra según pi.Name — el PropertyInfo.Name actual, leído ahora, en tiempo de ejecución. Después de que Nebula renombre CustomerName a b y el tipo Order a a, eso es exactamente lo que devuelve la reflexión, así que el StructureValue sale con los miembros b, c, d y una etiqueta de tipo a. Un sink JSON los escribe como sus claves. El evento es completo y correcto; sus nombres han desaparecido.

order : OrderCustomerName, Total…{Order} — camino escalarllama a ToString() / PrintMembers() del recordlos nombres son literales ldstr del métodoCheckout for Order {CustomerName = Dana, Total = 49.90 }{@Order} — camino de desestructuraciónrefleja GetProperties() en ejecuciónlee el PropertyInfo.Name vivo (renombrado)Checkout for a {b = Dana, c = 49.90 }
El mismo objeto, registrado de dos formas. El camino escalar lee nombres fijados en el ToString() del record; el camino de desestructuración los lee en vivo desde los metadatos, así que solo él sigue al renombrado.

Las plantillas de mensaje también son literales

La tercera forma habitual evita los objetos por completo:

Log.Information("Checkout for {Customer} total {Total} x{Items}",
    order.CustomerName, order.Total, order.Items);

Los nombres de token Customer, Total e Items viven en la cadena de plantilla "Checkout for {Customer} …", que es un único ldstr en tu método. Serilog analiza ese literal en tiempo de ejecución y empareja cada token con un argumento posicional. Renombrar las propiedades detrás de order.CustomerName no cambia nada que la plantilla pueda ver — el evento estructurado tiene las claves Customer, Total, Items sin importar cómo se llamen los miembros subyacentes. Las plantillas explícitas son inmunes al renombrado por construcción. (Nebula aún puede cifrar la cadena de plantilla; el valor que Serilog analiza tras el descifrado es byte a byte el original, así que los nombres de token quedan inalterados.)

Así que la regla es limpia: los nombres de token y el ToString() de un record son literales de tiempo de compilación y sobreviven; la desestructuración {@...} refleja nombres vivos y sigue al renombrado. La misma división explica las sorpresas relacionadas — ForContext<T>() establece SourceContext a typeof(T).FullName leído en ejecución, así que informa el nombre del tipo renombrado, y cualquier enricher que refleje sobre un tipo para añadir propiedades también lee nombres renombrados.

Acotar Nebula

Si quieres registros estructurados y ofuscación completa, decide por objeto en qué lado de la división está. Los objetos que desestructuras en registros suelen ser DTO simples sin lógica que valga la pena ocultar, así que conserva sus nombres de miembro públicos y renombra todo lo demás. Pon esas formas bajo un único espacio de nombres:

{
  "schemaVersion": 1,
  "inputs": ["bin/Release/net8.0/Checkout.dll"],
  "outputDirectory": "protected",
  "encryptStrings": true,
  "controlFlowObfuscation": true,
  "renaming": {
    "rules": [
      { "pattern": "Checkout.Logging.Shapes.*", "action": "keep", "members": "public" },
      { "pattern": "Checkout.*",                "action": "rename" }
    ]
  }
}
nebula protect --config nebula.config.json

La primera regla conserva los nombres de propiedad públicos de tus formas de registro para que los eventos desestructurados sigan siendo legibles; members: "public" aún permite que los campos privados y métodos de esos tipos se renombren, y los tipos conservados mantienen su ofuscación de flujo de control y cifrado de cadenas — renuncias a unos pocos nombres de propiedad, no al código que hay detrás. Todo lo que esté fuera de ese espacio de nombres — tus precios, tu licenciamiento, tu lógica de dominio — se renombra a a, b, c.

Si prefieres no conservar nada con nombre, ve por el otro camino: registra con plantillas explícitas en el código sensible y proyecta los objetos a través de una forma elegida en vez de reflejar la real.

Log.Logger = new LoggerConfiguration()
    .Destructure.ByTransforming<Order>(o => new { o.Items, Total = o.Total })
    .CreateLogger();

ByTransforming ejecuta tu lambda, así que los nombres de la forma anónima (Items, Total) son literales que el compilador emite — estables, y bajo tu control, con los campos que no quieres en los registros simplemente omitidos.

Cuándo se rompe

Tres bordes son más silenciosos que el caso principal. Primero, el filtrado por SourceContext: si un sink, un sub-logger o una consulta de registro enruta por SourceContext, un nombre de tipo renombrado de ForContext<T>() deja de coincidir — conserva los nombres de tipo por los que filtras, o establece el contexto con una cadena explícita: ForContext("SourceContext", "Checkout"). Segundo, el registro generado por fuente vía [LogProperties] o LoggerMessage es lo opuesto de la desestructuración: el generador fija el nombre de cada propiedad en el método generado como literal en compilación, así que esos nombres sobreviven al renombrado igual que un token de plantilla — sin regla de conservación necesaria. Tercero, la cobertura: el renombrado es invisible hasta que un evento dado realmente se dispara, así que verifica la salida de registro de la compilación protegida en una prueba de humo, no la de la compilación de depuración, antes de confiar en ella en producción.

Conclusión

La ofuscación no rompe Serilog; reescribe el único tipo de nombre que Serilog lee en tiempo de ejecución. Una desestructuración {@Order} refleja sobre propiedades vivas, así que el renombrado convierte sus claves en b y c; un escalar {Order}, el ToString() de un record y cada {Token} de una plantilla de mensaje son literales de tiempo de compilación que pasan intactos. Decide qué objetos pertenecen a los registros, conserva solo los nombres públicos de esas formas y deja que Nebula.NET renombre el resto. Abre el resultado en Glass.NET para confirmar que tu lógica se lee como a, b, c mientras que tus formas de registro siguen deletreando los nombres que tu equipo de soporte necesita.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.