Logging nested JSON object with JSON.stringify(...)

[joswarmer]

I am trying to log a stringified JSON object using JSON.stringify(...). The stringified object contains single brackets, and therefore the logging is trying to evaluate the text inside the JSON string.

For the outermost curly braces, it is easy to double them so they are escaped for logtape.
For nested JSON objetcs, there are curly braces inside the JSON string at multiple places.

Having doubled the outermost curly braces I now get undefined for nested objects.
For example when logging the following object I double the outer braces:

const message = {
            messageKind: "Monitor",
            delta: { a: "aaa" }
        }
logger.info(`message is {${JSON.stringify(message)}}`)

The result is

{"messageKind":"Monitor","delta":undefined}

Is there a way to escape all of these curly braces? Or maybe to turn off the interpolation through a formatter option?

[paulodearaujo]

You do not need to escape the JSON. Pass it as a placeholder value instead of putting it directly into the message template:

const message = {
  messageKind: "Monitor",
  delta: { a: "aaa" },
};

logger.info("message is {json}", {
  json: JSON.stringify(message),
});

The braces inside json are data, so LogTape does not parse them again. Only the first string ("message is {json}") is parsed as the message template.

Even better, keep the object structured and let the configured formatter render it:

logger.info("message is {message}", { message });

Or, if you do not need a text message at all:

logger.info({ message });

That preserves messageKind and delta as structured data for JSON sinks, filtering, and indexing. LogTape documents the message-plus-properties form in Structured logging.

The text formatter already knows how to render object placeholder values: it uses util.inspect() on Node/Bun, Deno.inspect() on Deno, and JSON serialization in browsers (formatter implementation). You can customize that value rendering, but there is no reason to disable interpolation for this case.

Doubling braces is only needed when literal braces are part of the message template itself. Moving the JSON into the properties argument avoids the escaping problem entirely.

[joswarmer]

Having changed to using logtape recently, I was not actively aware how to use the structured logging approach.
This works quite well, thanks for the quick and extensive answer.

[joswarmer]

A hopefully simple followup question. The object is logged with each property as a key-value pair on a separate line.
I looked into the formatter options hoping to find an option to keep all properties on one line, making the log more concise.
I could not find such an option. Am I missing something? Or is there no such option?

I am using the console sink + pretty formatter and though that inpectOptions.compact: true would be what I needed, but nu such luck.

[paulodearaujo]

You're not missing an option. One quick check first: the option is inspectOptions; the post spells it inpectOptions. If the same typo is in the configuration, it will not take effect.

Even with the spelling corrected, compact: true does not guarantee a single line. The pretty formatter passes that option to the runtime inspector, which may still split a large object across lines. LogTape also enables wordWrap by default.

For an object interpolated into the message, this disables LogTape's own wrapping:

formatter: getPrettyFormatter({
  wordWrap: false,
  inspectOptions: { compact: true },
})

That may be enough for smaller objects, but it still does not force the runtime inspector to return one line.

If you are using properties: true, there is currently no option to put all top-level properties on the same line. formatProperties() deliberately starts each property on a new line, while inspectOptions only controls how each value is rendered.

On Node and Bun, breakLength: Infinity would keep util.inspect() on one line because the implementation forwards the options. However, PrettyFormatterOptions does not expose breakLength, so that is an implementation detail rather than a supported portable setting.

If one physical line is required, jsonLinesFormatter or a small custom formatter is the reliable option. If the goal is only to make interpolated objects less verbose, wordWrap: false plus compact: true is the supported configuration to try.

[joswarmer]

Thanks, I'll experiment with the solutions you propose.