Why are my structured logs still unstructured strings?

// ❌ Concatenation or interpolation: the logger only ever sees the finished string
_logger.LogInformation("Processing order for user " + userId);
_logger.LogInformation($"Order {orderId} processed with amount {amount}");

// ✅ A message template: the braces name a field, the trailing arguments fill it
_logger.LogInformation("Order {OrderId} processed with amount {Amount}", orderId, amount);
// → Message "Order ord-9f2a processed with amount 142.5", fields OrderId, Amount

// ❌ Concatenation or String.format: one opaque message
log.info("Processing order for user " + userId);
log.info(String.format("Order %s processed with amount %s", orderId, amount));

// ✅ SLF4J 2 key-value pairs: named fields next to a constant message
log.atInfo()
   .addKeyValue("order.id", orderId)
   .addKeyValue("order.amount", amount)
   .log("Order processed");
// Logback JsonEncoder → "kvpList": [{"order.id":"ord-9f2a"},{"order.amount":"142.5"}]

// ❌ Concatenation or fmt.Sprintf: slog gets a msg and nothing else
slog.Info("processing order for user " + userID)
slog.Info(fmt.Sprintf("order %s processed with amount %.2f", orderID, amount))

// ✅ Key-value pairs after a constant message
slog.Info("order processed", "order.id", orderID, "order.amount", amount)
// → {"msg":"order processed","order.id":"ord-9f2a","order.amount":142.5}

# ❌ f-string or concatenation: one opaque message
logger.info(f"Order {order_id} processed with amount {amount}")

# ✅ Fields in extra= (stdlib), or keyword arguments with structlog
logger.info("Order processed", extra={"order.id": order_id, "order.amount": amount})
log.info("order.processed", order_id=order_id, amount=amount)   # structlog
# OTel logging handler → attributes {"order.id": "ord-9f2a", "order.amount": 142.5}

// In C#, a template placeholder IS a field — this is the pattern to use.
_logger.LogInformation("Order {OrderId} processed", orderId);
// The name inside the braces becomes the field name, so keep it stable across calls:
// "{OrderId}" here and "{orderId}" elsewhere are two different fields.

// ⚠️ SLF4J {} placeholders defer formatting, but they have no names
log.info("Order {} processed with amount {}", orderId, amount);
// Logback JsonEncoder → "arguments": ["ord-9f2a","142.5"] — positional, unnamed
// Use addKeyValue (above) when you need to query by field.

// ⚠️ A value without a key: slog pairs it with a made-up key
slog.Info("order processed", orderID)
// → {"msg":"order processed","!BADKEY":"ord-9f2a"}
// go vet catches it: "call to slog.Logger.Info missing a final value"

# ⚠️ %-style arguments defer formatting, but they aren't fields
logger.info("Order %s processed with amount %s", order_id, amount)
# OTel logging handler → body "Order ord-9f2a processed with amount 142.5", attributes {}
# Only extra= (or structlog keyword arguments) becomes a field.

// ❌ A JSON string inside the message: the structure is trapped in text
_logger.LogInformation("Order: " + JsonSerializer.Serialize(order));

// ⚠️ {@Order} destructures only under Serilog. With the built-in JSON console or the
// OpenTelemetry provider it becomes one string field literally named "@Order":
_logger.LogInformation("Order processed {@Order}", order);
// MEL / OTel → "@Order": "Order { Id = ord-9f2a, Amount = 142,5, Status = paid }"
// Serilog     → "Order": {"Id":"ord-9f2a","Amount":142.5,"Status":"paid"}

// ✅ Works with every provider: name the fields you need
_logger.LogInformation("Order {OrderId} processed: amount {Amount}, status {Status}",
    order.Id, order.Amount, order.Status);

// ❌ toString() or a JSON string in the message
log.info("Order: " + order);
// → "message":"Order: Order[id=ord-9f2a, amount=142.5, status=paid]"

// ✅ Name the fields you need
log.atInfo()
   .addKeyValue("order.id", order.id())
   .addKeyValue("order.amount", order.amount())
   .addKeyValue("order.status", order.status())
   .log("Order processed");

// ❌ A JSON string in the message
b, _ := json.Marshal(order)
slog.Info("order: " + string(b))

// ⚠️ slog.Any with a struct nests in the JSON handler, but the OpenTelemetry
// bridge (otelslog) flattens it to one string: "{ID:ord-9f2a Amount:142.5 Status:paid}"
slog.Info("order processed", "order", order)

// ✅ A group survives both handlers as real nested fields
slog.Info("order processed", slog.Group("order",
	"id", order.ID, "amount", order.Amount, "status", order.Status))

# ❌ A JSON string in the message
logger.info("Order: " + json.dumps(order))

# ✅ Flat, named fields
logger.info("Order processed", extra={
    "order.id": order["id"], "order.amount": order["amount"], "order.status": order["status"],
})