This map is copied into the SLF4J MDC by the with-context macro.

You are free to take control of it for MDC-related purposes as it doesn’t directly affect Pedestal’s logging implementation.

This map also includes all options that were passed into with-context.

Return the current active span; Returns nil if there isn’t an active span.

Returns the default formatter (used to convert the event map to a string) used when the :io.pedestal.log/formatter key is not present in the log event. The default is pr-str, but can be overridden via JVM property io.pedestal.log.formatter or environment variable PEDESTAL_LOG_FORMATTER.

This is the default recorder of all metrics. This value is configured by setting the JVM Property io.pedestal.log.defaultMetricsRecorder or the environment variable PEDESTAL_METRICS_RECORDER. The value of the setting should be a namespaced symbol that resolves to a 0-arity function or nil. That function should return something that satisfies the MetricRecorder protocol. If no function is found, metrics will be reported only to JMX via a DropWizard MetricRegistry.

This is the default Tracer, registered as the OpenTracing’s GlobalTracer. This value is configured by setting the JVM Property io.pedestal.log.defaultTracer or the environment variable PEDESTAL_TRACER. The value of the setting should be a namespaced symbol that resolves to a 0-arity function or nil. That function should return something that satisfies the TracerOrigin protocol. If no function is found, the GlobalTracer will default to the NoopTracer and GlobalTracer/isRegistered will be false.

Given a span, finish the span and return it.

Format a given metric name, regardless of type, into a string

This function provides basic/core logging functionality as a function. You may prefer to use this if you need custom logging functionality beyond what is offered by the standard Pedestal logging macros (which in turn just call the protocols).

Deprecated with no replacement; the LoggerSource protocol and various configurable options for the main logging macros should be sufficient.

Given a map of logging information, and optionally a default log-level keyword (if not found in the map) – default is :info, Determine the appropriate logger to use, determine if logging-level is enabled, format the logging message, and return the result of calling the appropriate logging function, dispatched to the logging protocols.

Special keys within the log message:

Key	Value	Description
:level	keyword	Log level to use for this message, defaults to default-level
:exception	Throwable
::logger	LoggerSource	The logger to use for this message, defaults to the override-logger or the SLF4J logger
::logger-name	String	Logger name to use, defaults to *ns*, which may be clojure.core depending on execution, so explicit is desired
::formatter	Function	A single argument function that converts a map to a loggable String; defaults to pr-str, via default-formatter

If using this function within a macro, you’re encouraged to merge all ‘meta’ information (like line info) into the log message map.

For example:

(defmacro log-macro [log-map]
  (let [named-log-map (if (::logger-name log-map)
                        log-map
                        (assoc log-map ::logger-name (name (ns-name *ns*))))
        final-log-map (assoc named-log-map :line (:line (meta &form)))]
    `(log ~final-log-map :info)))

Used internally by the logging macros to map from a level keyword to a protocol method on LoggerSource.

Log to a given span, and return the span.

If the log message is a string, the message is logged as an info ‘message’. If the log message is a keyword, the message is logged as an ‘event’, without a message. If the log message is a Throwable, the message is logged as an ‘error’, with info extracted from the Throwable If the log message is a map, the map is logged as a series of fields/values.

This also supports the same logging style as io.pedestal.log – with any number of log keys and values.

You are encouraged to follow the OpenTracing semantics

Adapts an underlying logger (such as defined by SLF4J) to io.pedestal.log.

For -trace, -debug, etc., the body will typically be a String, formatted from the event map; if you write code that directly invokes these methods, but use the io.pedestal.log implementation of LoggerSource for SLF4J, then Strings will pass through unchanged, but other Clojure types will be converted to strings via pr-str.

If you write your own LoggerSource, you understand the same requirements: io.pedestal.log’s macros will only supply a String body, but other code may pass other types.

Returns a logger which satisfies the LoggerSource protocol.

Invoke this once when starting your application to redirect all java.util.logging log messages to SLF4J. The current project’s dependencies must include org.slf4j/jul-to-slf4j.

The key to use when formatting *mdc-context* for storage into the MDC (via -put-mdc). io.pedestal.log uses only this single key of the underlying LoggingMDC implementation.

Create a metric-registry. Optionally pass in single-arg functions, which when passed a registry, create, start, and return a reporter.

Metrics support in the pedestal.log library has been deprecated.

Override of the default logger source, from symbol property io.pedestal.log.overrideLogger or environment variable PEDESTAL_LOGGER.

Given an operation name, and optionally a parent Span, and optionally a map of options return a new Span with the operation name set, started, and active.

Options are Tracer/TraceOrigin specific but all platforms support a minimum of: :initial-tags - a map of initial tags for the span

If the parent is not set, the span has no parent (ie: current active spans are ignored). If the parent is nil, the behavior is Tracer/TraceOrigin specific – by default, the span has no parent.

Logs expr and its value at DEBUG level, returns value.

Tag a given span.

Tags can be expressed as: - a single tag key and tag value - a sequence of tag-key tag-values. - a map of tag-keys -> tag-values

Telemetry support in the pedestal.log library has been deprecated.

Telemetry support in the pedestal.log library has been deprecated.

Telemetry support in the pedestal.log library has been deprecated.

Telemetry support in the pedestal.log library has been deprecated.

Telemetry support in the pedestal.log library has been deprecated.

Given a map of keys/values/options and a body, Set the map into the MDC via the mdc-context binding.

The MDC used defaults to the SLF4J MDC unless the :io.pedestal.log/mdc option is specified (see Options).

By default, the map is formatted into a string value and stored under the “io.pedestal” key.

Caveats: SLF4J MDC, only maintains thread-local bindings, users are encouraged to use app-specific MDC implementations when needed.

Since SLF4J MDC manages data on a per-thread basis, false information may be contained in the MDC if threads are recycled. Refer to the slf4j docs for more information.

Options:

Key	Value	Description
::formatter	Function	Converts map to loggable value (a String), default via default-formatter is pr-str
::mdc	LoggingMDC	Defaults to the SLFJ MDC.

Given a key, value, and body, associates the key-value pair into the mdc-context only for the scope/execution of body, and formats and stores the mdc-context into the SLF4J MDC under the ‘io.pedestal’ key (via io.pedestal.log/mdc-context-key) using the formatter (from the :io.pedestal.log/formatter option, or default-formatter.

This macro has been deprecated, use with-context instead.

• This macro expands to nil if the provided k is nil; this is likely a day-1 bug
• This macro bypasses the LoggingMDC protocol, invoking SLF4J methods directly