Ce que le renommage fait à votre sortie Serilog
Obfusquez une application qui journalise avec Serilog et vos événements structurés peuvent silencieusement passer de { CustomerName, Total } à { b, c } — mais seulement sur l'un des deux chemins de code. Cet article montre pourquoi déstructurer un objet avec {@Order} reflète les noms de propriété vivants (que le renommage réécrit) tandis que le {Order} d'un record et les jetons explicites du modèle de message sont des littéraux figés qui survivent, puis cadre Nebula.NET pour garder des journaux lisibles sans désobfusquer votre logique.
Vous obfusquez une application de bureau, vous la publiez, et les journaux structurés qu”elle téléverse pour le support commencent à revenir illisibles — ni absents, ni malformés, juste pleins de { "b": "Dana Okafor", "c": 49.90 } là où la version précédente disait { "CustomerName": "...", "Total": ... }. Rien n”a levé d”exception. Serilog a fonctionné exactement comme avant. Les noms des propriétés ont changé, parce que l”une des deux façons de donner un objet à Serilog lit ces noms à l”exécution, et le renommage est précisément ce qui les réécrit.
La vraie question
Serilog ne voit jamais votre source. Il voit une chaîne de modèle de message et quelques valeurs d”arguments, et il les transforme en un ensemble de propriétés nommées. La question pour une build obfusquée est donc la question habituelle : quels noms de propriété Serilog a-t-il capturés comme texte littéral voyageant intact dans votre assembly, et lesquels a-t-il capturés en réfléchissant sur des métadonnées vivantes que le renommage a réécrites ? Réussissez cette distinction et vos journaux restent lisibles à travers l”obfuscation. Ratez-la et vos événements structurés se renomment silencieusement eux-mêmes.
Deux valeurs, deux chemins de code
Prenez une journalisation de paiement triviale sur 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 seule différence est le @. Serilog analyse chaque modèle et, pour le jeton nommé Order, enregistre un indice de capture : le premier est Destructuring.Default (traiter comme scalaire), le second est Destructuring.Destructure. Cet indice décide du chemin.
Le chemin scalaire, à l”intérieur du PropertyValueConverter de Serilog, aboutit à un ScalarValue construit à partir de order.ToString(). Pour un record C#, ToString() est généré par le compilateur, et il est généré pour écrire le nom de chaque membre comme chaîne littérale :
// Order.PrintMembers, decompiled
builder.Append("CustomerName = ");
builder.Append((object)CustomerName);
builder.Append(", Total = ");
builder.Append(Total.ToString());
builder.Append(", Items = ");
builder.Append(Items.ToString());
Ces chaînes "CustomerName = " sont des chargements ldstr dans le tas #US. Renommez la propriété CustomerName en b et cette méthode imprime toujours CustomerName = …, parce que le texte a été figé à la compilation et n”a plus rien à voir avec le nom de métadonnées de la propriété. La ligne de journal scalaire survit intacte au renommage.
Le chemin de déstructuration n”appelle pas ToString(). Il parcourt l”objet :
// 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);
Chaque propriété capturée est nommée d”après pi.Name — le PropertyInfo.Name actuel, lu maintenant, à l”exécution. Après que Nebula renomme CustomerName en b et le type Order en a, c”est exactement ce que la réflexion retourne, donc le StructureValue sort avec les membres b, c, d et une étiquette de type a. Un sink JSON les écrit comme ses clés. L”événement est complet et correct ; ses noms ont disparu.
Les modèles de message sont aussi des littéraux
La troisième forme courante contourne entièrement les objets :
Log.Information("Checkout for {Customer} total {Total} x{Items}",
order.CustomerName, order.Total, order.Items);
Les noms de jeton Customer, Total et Items vivent dans la chaîne de modèle "Checkout for {Customer} …", qui est un unique ldstr dans votre méthode. Serilog analyse ce littéral à l”exécution et apparie chaque jeton avec un argument positionnel. Renommer les propriétés derrière order.CustomerName ne change rien que le modèle puisse voir — l”événement structuré a les clés Customer, Total, Items quel que soit le nom des membres sous-jacents. Les modèles explicites sont insensibles au renommage par construction. (Nebula peut toujours chiffrer la chaîne de modèle ; la valeur que Serilog analyse après déchiffrement est octet pour octet l”originale, donc les noms de jeton sont inchangés.)
La règle est donc nette : les noms de jeton et le ToString() d”un record sont des littéraux de compilation et survivent ; la déstructuration {@...} reflète des noms vivants et suit le renommage. La même division explique les surprises connexes — ForContext<T>() définit SourceContext à typeof(T).FullName lu à l”exécution, donc il rapporte le nom du type renommé, et tout enricher qui réfléchit sur un type pour ajouter des propriétés lit aussi des noms renommés.
Cadrer Nebula
Si vous voulez des journaux structurés et une obfuscation complète, décidez par objet de quel côté de la division il se trouve. Les objets que vous déstructurez dans les journaux sont généralement de simples DTO sans logique à cacher, alors conservez leurs noms de membres publics et renommez tout le reste. Placez ces formes dans un seul espace de noms :
{
"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 première règle conserve les noms de propriété publics de vos formes de journal pour que les événements déstructurés restent lisibles ; members: "public" laisse encore les champs privés et méthodes de ces types se renommer, et les types conservés gardent leur obfuscation de flux de contrôle et leur chiffrement de chaînes — vous abandonnez quelques noms de propriété, pas le code derrière. Tout ce qui est en dehors de cet espace de noms — vos tarifs, votre licence, votre logique métier — est renommé en a, b, c.
Si vous préférez ne rien conserver de nommé, prenez l”autre chemin : journalisez avec des modèles explicites dans le code sensible et projetez les objets à travers une forme choisie plutôt que de refléter la vraie.
Log.Logger = new LoggerConfiguration()
.Destructure.ByTransforming<Order>(o => new { o.Items, Total = o.Total })
.CreateLogger();
ByTransforming exécute votre lambda, donc les noms de la forme anonyme (Items, Total) sont des littéraux que le compilateur émet — stables, et sous votre contrôle, avec les champs que vous ne voulez pas dans les journaux simplement omis.
Quand ça casse
Trois bords sont plus silencieux que le cas principal. D”abord, le filtrage par SourceContext : si un sink, un sous-logger ou une requête de journal route sur SourceContext, un nom de type renommé de ForContext<T>() cesse de correspondre — conservez les noms de type sur lesquels vous filtrez, ou définissez le contexte avec une chaîne explicite : ForContext("SourceContext", "Checkout"). Ensuite, la journalisation générée par source via [LogProperties] ou LoggerMessage est l”opposé de la déstructuration : le générateur fige le nom de chaque propriété dans la méthode générée comme littéral à la compilation, donc ces noms survivent au renommage exactement comme un jeton de modèle — aucune règle de conservation nécessaire. Enfin, la couverture : le renommage est invisible jusqu”à ce qu”un événement donné se déclenche réellement, alors vérifiez la sortie de journal de la build protégée dans un test de fumée, pas celle de la build de débogage, avant de lui faire confiance sur le terrain.
À retenir
L”obfuscation ne casse pas Serilog ; elle réécrit le seul type de nom que Serilog lit à l”exécution. Une déstructuration {@Order} réfléchit sur des propriétés vivantes, donc le renommage transforme ses clés en b et c ; un scalaire {Order}, le ToString() d”un record et chaque {Token} d”un modèle de message sont des littéraux de compilation qui passent intacts. Décidez quels objets appartiennent aux journaux, conservez uniquement les noms publics de ces formes, et laissez Nebula.NET renommer le reste. Ouvrez le résultat dans Glass.NET pour confirmer que votre logique se lit comme a, b, c tandis que vos formes de journal épellent toujours les noms dont votre équipe de support a besoin.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.