Logbook

https://github.com/zalando/logbook
Admin
Logbook is a library for HTTP request and response logging, designed to capture and display detailed...
Tokens:81,372
Snippets:543
Trust Score:8.3
License:MIT
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### LogbookClient usage example

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-server-integrations.md

Shows how to install the LogbookClient plugin on an HttpClient and configure the Logbook instance.

```kotlin
val client = HttpClient {
    install(LogbookClient) {
        logbook = Logbook.create()
    }
}
```

--------------------------------

### LogbookServer usage example

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-server-integrations.md

Shows how to install the LogbookServer plugin in a Ktor application and configure the Logbook instance.

```kotlin
install(LogbookServer) {
    logbook = Logbook.create()
}
```

--------------------------------

### SplunkHttpLogFormatter request example

Source: https://github.com/zalando/logbook/blob/main/README.md

Example Splunk request log output produced by SplunkHttpLogFormatter. Shows key-value pairs for a request.

```text
origin=remote type=request correlation=2d66e4bc-9a0d-11e5-a84c-1f39510f0d6b protocol=HTTP/1.1 sender=127.0.0.1 method=POST uri=http://example.org/test host=example.org scheme=http port=null path=/test headers={Accept=[application/json], Content-Type=[text/plain]} body=Hello world!
```

--------------------------------

### Example Logbook YAML configuration

Source: https://github.com/zalando/logbook/blob/main/README.md

Example configuration showing include/exclude predicates, filter and secure-filter flags, format style, strategy, minimum status, obfuscation, chunk size, and attribute extractors.

```yaml
logbook:
  predicate:
    include:
      - path: /api/**
        methods: 
         - GET
         - POST
      - path: /actuator/**
    exclude:
      - path: /actuator/health
      - path: /api/admin/**
        methods: 
         - POST
  filter.enabled: true
  secure-filter.enabled: true
  format.style: http
  strategy: body-only-if-status-at-least
  minimum-status: 400
  obfuscate:
    headers:
      - Authorization
      - X-Secret
    parameters:
      - access_token
      - password
  write:
    chunk-size: 1000
  attribute-extractors:
    - type: JwtFirstMatchingClaimExtractor
      claim-names: [ "sub", "subject" ]
      claim-key: Principal
    - type: JwtAllMatchingClaimsExtractor
      claim-names: [ "sub", "iat" ]

```

--------------------------------

### Usage example with DefaultSink

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-json.md

Shows how to configure Logbook with FastJsonHttpLogFormatter and DefaultHttpLogWriter using DefaultSink.

```java
import org.zalando.logbook.json.FastJsonHttpLogFormatter;
import org.zalando.logbook.core.DefaultSink;
import org.zalando.logbook.core.DefaultHttpLogWriter;

Logbook logbook = Logbook.builder()
        .sink(new DefaultSink(new FastJsonHttpLogFormatter(), new DefaultHttpLogWriter()))
        .build();
```

--------------------------------

### HttpHeaders usage example

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-api.md

Shows how to use HttpHeaders: create with of(), update, apply, and delete headers, then retrieve a value with getFirst(). The example demonstrates the fluent API and that getFirst returns the first value for the header.

```java
HttpHeaders headers = HttpHeaders.of("X-Trace", "abc")
        .update("Accept", "application/json")
        .apply("X-Trace", v -> List.of("def"))
        .delete("Accept");
String first = headers.getFirst("X-Trace"); // "def"
```

--------------------------------

### ExtendedLogFormatSink default log output example

Source: https://github.com/zalando/logbook/blob/main/README.md

Example log output in Extended Log Format (ELF) using the default fields. Shows the format and order of the fields.

```text
2019-08-02 08:16:41 185.85.220.253 localhost POST /search ?q=zalando 200 21 20 0.125 HTTP/1.1 "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0" "name=value" "https://example.com/page?q=123"
```

--------------------------------

### Install LogbookClient on Ktor HttpClient

Source: https://github.com/zalando/logbook/blob/main/README.md

Installs the LogbookClient feature on a Ktor HttpClient to log client requests and responses. Use with the logbook-ktor-client module.

```kotlin
private val client = HttpClient(CIO) {
    install(LogbookClient) {
        logbook = logbook
    }
}

```

--------------------------------

### Glob usage example

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-common.md

Shows how to use Glob.compile to create predicates for path matching. Demonstrates that trailing /** matches everything, while * does not cross '/'.

```java
import org.zalando.logbook.common.Glob;

Predicate<String> health = Glob.compile("/health");
Predicate<String> admin = Glob.compile("/admin/**");
assert health.test("/health");
assert admin.test("/admin/users/42");   // trailing /** matches everything
assert !Glob.compile("/admin/*").test("/admin/users/42"); // * does not cross '/'
```

--------------------------------

### SplunkHttpLogFormatter response example

Source: https://github.com/zalando/logbook/blob/main/README.md

Example Splunk response log output produced by SplunkHttpLogFormatter. Shows key-value pairs for a response.

```text
origin=local type=response correlation=2d66e4bc-9a0d-11e5-a84c-1f39510f0d6b duration=25 protocol=HTTP/1.1 status=200 headers={Content-Type=[text/plain]} body=Hello world!
```

--------------------------------

### Manual registration example

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-servlet.md

Shows how to manually register the LogbookFilter in a Spring Boot application or via web.xml.

```APIDOC
## Manual registration example

### Description
Registers the LogbookFilter as a servlet filter with the appropriate dispatcher types and order.

### Method
Configuration

### Endpoint
N/A (configuration)

### Parameters
- `dispatcherTypes` (DispatcherType...) - Required - The dispatcher types (REQUEST, ASYNC).
- `order` (int) - Required - The filter order (e.g., `Ordered.LOWEST_PRECEDENCE`).

### Request Example
```java
FilterRegistrationBean<LogbookFilter> registration = new FilterRegistrationBean<>(new LogbookFilter(Logbook.create()));
registration.setName("logbookFilter");
registration.setDispatcherTypes(DispatcherType.REQUEST, DispatcherType.ASYNC);
registration.setOrder(Ordered.LOWEST_PRECEDENCE);
```

### Response
N/A (configuration)
```

--------------------------------

### CurlHttpLogFormatter request example

Source: https://github.com/zalando/logbook/blob/main/README.md

Example cURL request rendered by CurlHttpLogFormatter. The formatter produces executable cURL commands for humans.

```bash
curl -v -X GET 'http://localhost/test' -H 'Accept: application/json'
```

--------------------------------

### MediaTypeQuery usage example

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-common.md

Shows how to use MediaTypeQuery.compile to create predicates for media type matching. Demonstrates that * in type or subtype is translated to .*? and parameters are ignored.

```java
import static org.zalando.logbook.common.MediaTypeQuery.compile;

Predicate<String> json = compile("application/*+json");
assert json.test("application/problem+json; charset=utf-8");
assert !json.test("text/plain");

Predicate<String> binary = compile("application/octet-stream", "image/*");
```

--------------------------------

### DefaultHttpLogFormatter Response Output Example

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-core.md

Shows the response format with duration, status line, headers, and body. The duration is printed in milliseconds.

```text

Outgoing Response: <correlation-id>
Duration: 25 ms
HTTP/1.1 200
Content-Type: application/json

{"value":"Hello world!"}

```

--------------------------------

### Usage example with ChunkingSink

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-core.md

Example usage of ChunkingSink wrapping a DefaultSink with JsonHttpLogFormatter and DefaultHttpLogWriter, with a chunk size of 2048.

```java
import org.zalando.logbook.Logbook;
import org.zalando.logbook.core.*;

Logbook logbook = Logbook.builder()
    .sink(new ChunkingSink(
        new DefaultSink(new JsonHttpLogFormatter(), new DefaultHttpLogWriter()),
        2048))
    .build();
```

--------------------------------

### OkHttpClient with GzipInterceptor and LogbookInterceptor

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-client-integrations.md

Usage example for the logbook-okhttp package. It builds an OkHttpClient with a GzipInterceptor added before the LogbookInterceptor, which is created with Logbook.create(). The GzipInterceptor transparently decompresses gzip responses so bodies can be logged.

```java
import okhttp3.OkHttpClient;
import org.zalando.logbook.Logbook;
import org.zalando.logbook.okhttp.GzipInterceptor;
import org.zalando.logbook.okhttp.LogbookInterceptor;

OkHttpClient client = new OkHttpClient.Builder()
        .addInterceptor(new GzipInterceptor())
        .addInterceptor(new LogbookInterceptor(Logbook.create()))
        .build();
```

--------------------------------

### Install LogbookServer on Ktor embeddedServer

Source: https://github.com/zalando/logbook/blob/main/README.md

Installs the LogbookServer feature on a Ktor embedded server to log server requests and responses. Use with the logbook-ktor-server module.

```kotlin
private val server = embeddedServer(CIO) {
    install(LogbookServer) {
        logbook = logbook
    }
}

```

--------------------------------

### Parsed Logbook request fields example

Source: https://github.com/zalando/logbook/blob/main/docs/scalyr.md

Example of the parsed fields resulting from applying the custom parser to a Logbook request log line. Shows how the JSON output is flattened into individual fields like httpCorrelation, httpMethod, and httpUri, enabling powerful queries.

```yaml
http: true
httpCorrelation: b7b143c7-a334-4a26-b800-1e97322efebc
httpHeadersAccept: [application/json]
httpHeadersAccept-Encoding: [gzip,deflate]
httpHeadersAuthorization: [XXX]
httpHeadersConnection: [Keep-Alive]
httpHeadersHost: [localhost:9021]
httpHeadersUser-Agent: [Apache-HttpClient/4.5.1 (Java/1.8.0_131)]
httpHeadersX-Flow-ID: [OWgtIWTdlMuKh97U]
httpMethod: GET
httpRemote: 172.31.157.206
httpType: request
httpUri: http://localhost:9021/oauth2/tokeninfo
```

--------------------------------

### Configure Feign with FeignLogbookLogger

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-client-integrations.md

Usage example from the class javadoc: builds a Feign client with the FeignLogbookLogger as logger and sets log level to FULL. The logger delegates all logging to Logbook.

```java
Logbook logbook = ...;
FeignLogbookLogger interceptor = new FeignLogbookLogger(logbook);
client = Feign.builder()
        .logger(interceptor)
        .logLevel(Logger.Level.FULL)
        .build();
```

--------------------------------

### Common Log Format Example

Source: https://github.com/zalando/logbook/blob/main/README.md

Example of the Common Log Format (CLF) output produced by the CommonsLogFormatSink. This is a standardized text format used by web servers for server log files.

```text
185.85.220.253 - - [02/Aug/2019:08:16:41 0000] "GET /search?q=zalando HTTP/1.1" 200 -
```

--------------------------------

### Usage example for JsonPathBodyFilters

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-json.md

Shows how to build a Logbook instance with multiple body filters: delete, replace with string, regex replace, and replace with number. Requires imports from org.zalando.logbook.json.JsonPathBodyFilters and java.util.regex.Pattern.

```java
import static org.zalando.logbook.json.JsonPathBodyFilters.jsonPath;
import static java.util.regex.Pattern.compile;

Logbook logbook = Logbook.builder()
        .bodyFilter(jsonPath("$.password").delete())
        .bodyFilter(jsonPath("$.active").replace("unknown"))
        .bodyFilter(jsonPath("$.name").replace(compile("^(\\w).+"), "$1."))
        .bodyFilter(jsonPath("$.grades.*").replace(1.0))
        .build();
```

--------------------------------

### Logbook.process(HttpRequest)

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-api.md

Starts the logging pipeline by processing an incoming or outgoing request. Returns a RequestWritingStage that allows writing the request and continuing to the response processing stage.

```APIDOC
## [PROCESS] Logbook.process(HttpRequest)

### Description
Starts the logging pipeline by processing an incoming (REMOTE) or outgoing (LOCAL) HTTP request. The return value is a staging object that coordinates the two-phase request/response logging lifecycle.

### Method
process (interface method)

### Endpoint
Logbook.process(HttpRequest request)

### Parameters
#### Parameters
- **request** (HttpRequest) - Required - The incoming (REMOTE) or outgoing (LOCAL) request to log.

### Response
#### Success Response (200)
- **RequestWritingStage** (interface) - A staging object that provides the write() method for the request phase.

### Request Example
```java
Logbook logbook = Logbook.create();
RequestWritingStage stage = logbook.process(request);
```

### Response Example
```java
ResponseProcessingStage responseStage = stage.write();
```
```

--------------------------------

### WebClient usage with LogbookExchangeFilterFunction

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-server-integrations.md

Usage example for WebClient with the LogbookExchangeFilterFunction. Creates a WebClient with the filter applied, enabling client-side logging for WebFlux.

```java
import org.zalando.logbook.Logbook;
import org.zalando.logbook.spring.webflux.LogbookExchangeFilterFunction;
import org.springframework.web.reactive.function.client.WebClient;

WebClient client = WebClient.builder()
        .filter(new LogbookExchangeFilterFunction(Logbook.create()))
        .build();
```

--------------------------------

### Example Logstash JSON output

Source: https://github.com/zalando/logbook/blob/main/README.md

Example JSON output produced by the LogstashLogbackSink. The http field contains the logbook request/response contents.

```json
{
  "@timestamp" : "2019-03-08T09:37:46.239+01:00",
  "@version" : "1",
  "message" : "GET http://localhost/test?limit=1",
  "logger_name" : "org.zalando.logbook.Logbook",
  "thread_name" : "main",
  "level" : "TRACE",
  "level_value" : 5000,
  "http" : {
     // logbook request/response contents
  }
}

```

--------------------------------

### DefaultHttpLogFormatter Request Output Example

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-core.md

Produces the HTTP-like line format for incoming requests, including correlation ID, remote address, request line, headers, and body. The trailing newline is dropped when the body is empty.

```text

Incoming Request: <correlation-id>
Remote: 127.0.0.1
GET /test HTTP/1.1
Accept: application/json

<body>

```

--------------------------------

### OriginExtractor implementation

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-attributes.md

Example implementation of AttributeExtractor that adds an 'origin' attribute from the request. Shows how to use HttpAttributes.of to create a singleton immutable attribute map.

```java
import org.zalando.logbook.HttpRequest;
import org.zalando.logbook.attributes.AttributeExtractor;
import org.zalando.logbook.attributes.HttpAttributes;

final class OriginExtractor implements AttributeExtractor {
    @Override
    public HttpAttributes extract(final HttpRequest request) {
        return HttpAttributes.of("origin", request.getOrigin());
    }
}
```

--------------------------------

### LogbookServer class definition

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-server-integrations.md

Defines the LogbookServerConfiguration class and the LogbookServer application plugin. It installs the DoubleReceive plugin and handles request/response logging.

```kotlin
class LogbookServerConfiguration { var logbook: Logbook = Logbook.create() }

@API(status = EXPERIMENTAL)
val LogbookServer = createApplicationPlugin(
    name = "LogbookServerPlugin",
    createConfiguration = ::LogbookServerConfiguration,
)
```

--------------------------------

### Configure Logbook filters

Source: https://github.com/zalando/logbook/blob/main/README.md

Configures Logbook filters for requests and responses, including query, header, and body filters. Filters run consecutively and can be chained. The example uses static imports for common filters and replaces sensitive data with placeholders.

```java
import static org.zalando.logbook.core.HeaderFilters.authorization;
import static org.zalando.logbook.core.HeaderFilters.eachHeader;
import static org.zalando.logbook.core.QueryFilters.accessToken;
import static org.zalando.logbook.core.QueryFilters.replaceQuery;

Logbook logbook = Logbook.builder()
        .requestFilter(RequestFilters.replaceBody(message -> contentType("audio/*").test(message) ? "mmh mmh mmh mmh" : null))
        .responseFilter(ResponseFilters.replaceBody(message -> contentType("*/*-stream").test(message) ? "It just keeps going and going..." : null))
        .queryFilter(accessToken())
        .queryFilter(replaceQuery("password", "<secret>"))
        .headerFilter(authorization())
        .headerFilter(eachHeader("X-Secret"::equalsIgnoreCase, "<secret>"))
        .build();
```

--------------------------------

### JSON Formatter Request Output

Source: https://github.com/zalando/logbook/blob/main/README.md

Example of the JSON formatter output for an incoming request. This format is designed for production use and is easily consumable by parsers and log consumers.

```json
{
  "origin": "remote",
  "type": "request",
  "correlation": "2d66e4bc-9a0d-11e5-a84c-1f39510f0d6b",
  "protocol": "HTTP/1.1",
  "sender": "127.0.0.1",
  "method": "GET",
  "uri": "http://example.org/test",
  "host": "example.org",
  "path": "/test",
  "scheme": "http",
  "port": null,
  "headers": {
    "Accept": ["application/json"],
    "Content-Type": ["text/plain"]
  },
  "body": "Hello world!"
}
```

--------------------------------

### JSON body before filtering

Source: https://github.com/zalando/logbook/blob/main/README.md

Example JSON body before applying the JSONPath filters shown above. It contains fields like password, active, address, friends, and grades.

```json
{
  "id": 1,
  "name": "Alice",
  "password": "s3cr3t",
  "active": true,
  "address": "Anhalter Straße 17 13, 67278 Bockenheim an der Weinstraße",
  "friends": [
    {
      "id": 2,
      "name": "Bob"
    },
    {
      "id": 3,
      "name": "Charlie"
    }
  ],
  "grades": {
    "Math": 1.0,
    "English": 2.2,
    "Science": 1.9,
    "PE": 4.0
  }
}
```

--------------------------------

### JSON Formatter Response Output

Source: https://github.com/zalando/logbook/blob/main/README.md

Example of the JSON formatter output for an outgoing response. Includes duration, status, headers, and body. This format is designed for production use.

```json
{
  "origin": "local",
  "type": "response",
  "correlation": "2d66e4bc-9a0d-11e5-a84c-1f39510f0d6b",
  "duration": 25,
  "protocol": "HTTP/1.1",
  "status": 200,
  "headers": {
    "Content-Type": ["text/plain"]
  },
  "body": "Hello world!"
}
```

--------------------------------

### HTTP Formatter Request Output

Source: https://github.com/zalando/logbook/blob/main/README.md

Example of the default HTTP formatter output for an incoming request. The format includes a correlation ID, request line, headers, and body. This style is intended for local development and debugging, not production.

```http
Incoming Request: 2d66e4bc-9a0d-11e5-a84c-1f39510f0d6b
GET http://example.org/test HTTP/1.1
Accept: application/json
Host: localhost
Content-Type: text/plain

Hello world!
```

--------------------------------

### Enable web-filter reactive server mode and context propagation

Source: https://github.com/zalando/logbook/blob/main/README.md

Sets the reactive server mode to web-filter so logging happens through LogbookWebFilter inside the WebFlux pipeline, after tracing has started. Also enables spring.reactor.context-propagation to bridge Reactor context to the MDC for trace ids.

```yaml
logbook:
  reactive:
    server-mode: web-filter

spring:
  reactor:
    # required for the trace id to reach the MDC, e.g. %X{traceId}
    context-propagation: auto

```

--------------------------------

### HTTP Formatter Response Output

Source: https://github.com/zalando/logbook/blob/main/README.md

Example of the default HTTP formatter output for an outgoing response. Includes correlation ID, duration, status line, headers, and body. This style is intended for local development and debugging, not production.

```http
Outgoing Response: 2d66e4bc-9a0d-11e5-a84c-1f39510f0d6b
Duration: 25 ms
HTTP/1.1 200
Content-Type: application/json

{"value":"Hello world!"}
```

--------------------------------

### JSON Formatter Inlined JSON Body

Source: https://github.com/zalando/logbook/blob/main/README.md

Example showing that JSON bodies (application/json and application/*+json) are inlined into the resulting JSON tree rather than escaped as strings. This is a note about the JSON formatter behavior.

```json
{
  "origin": "local",
  "type": "response",
  "correlation": "2d66e4bc-9a0d-11e5-a84c-1f39510f0d6b",
  "duration": 25,
  "protocol": "HTTP/1.1",
  "status": 200,
  "headers": {
    "Content-Type": ["application/json"]
  },
  "body": {
    "greeting": "Hello, world!"
  }
}
```

--------------------------------

### Create Logbook with defaults

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-api.md

Shows how to create a Logbook instance with all default settings.

```java
import org.zalando.logbook.Logbook;

Logbook logbook = Logbook.create(); // all defaults
```

--------------------------------

### Full manual pipeline

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-api.md

Demonstrates the manual pipeline for processing a request and response through the Logbook stages.

```java
// Full manual pipeline
Logbook logbook = Logbook.create();
logbook.process(request).write()          // request written
      .process(response)                  // response stage
      .write();                           // response written
```

--------------------------------

### Logbook.create()

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-api.md

Static factory method that creates a Logbook instance with all default settings. The default implementation uses the builder with defaults for strategy, sink, condition, etc.

```APIDOC
## [FACTORY] Logbook.create()

### Description
Static factory that creates a new Logbook instance using the default builder configuration. This is the simplest way to obtain a Logbook for logging HTTP requests and responses.

### Method
create (static method)

### Endpoint
Logbook.create()

### Parameters
#### Parameters
None

### Response
#### Success Response (200)
- **Logbook** (interface) - A configured Logbook instance.

### Request Example
```java
Logbook logbook = Logbook.create();
```

### Response Example
```java
// Use the logbook instance
```
```

--------------------------------

### Usage: building a Logbook with Logbook.builder()

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-api.md

Shows how to construct a Logbook instance using Logbook.builder(). It sets a condition to exclude /health requests, adds query, header, and body filters, and configures a default sink with a default formatter and writer. Requires logbook-core for the filters and sink classes.

```java
import org.zalando.logbook.*;
import org.zalando.logbook.core.DefaultSink;
import org.zalando.logbook.core.DefaultHttpLogFormatter;
import org.zalando.logbook.core.DefaultHttpLogWriter;

Logbook logbook = Logbook.builder()
    .condition(request -> !request.getPath().startsWith("/health"))
    .queryFilter(QueryFilters.accessToken())          // from logbook-core
    .headerFilter(HeaderFilters.authorization())
    .bodyFilter(BodyFilters.defaultValue())
    .sink(new DefaultSink(new DefaultHttpLogFormatter(), new DefaultHttpLogWriter()))
    .build();
```

--------------------------------

### CompositeAttributeExtractor usage

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-attributes.md

Usage example for CompositeAttributeExtractor. Combines OriginExtractor and JwtFirstMatchingClaimExtractor into a single attribute extractor.

```java
import org.zalando.logbook.Logbook;
import org.zalando.logbook.core.attributes.CompositeAttributeExtractor;
import org.zalando.logbook.core.attributes.JwtFirstMatchingClaimExtractor;

Logbook logbook = Logbook.builder()
        .attributeExtractor(new CompositeAttributeExtractor(List.of(
                new OriginExtractor(),
                JwtFirstMatchingClaimExtractor.builder().build())))
        .build();
```

--------------------------------

### JwtAllMatchingClaimsExtractor usage

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-attributes.md

Usage example for JwtAllMatchingClaimsExtractor. Configures Logbook to extract claims sub, iss, and aud.

```java
import org.zalando.logbook.core.attributes.JwtAllMatchingClaimsExtractor;

Logbook logbook = Logbook.builder()
        .attributeExtractor(JwtAllMatchingClaimsExtractor.builder()
                .claimNames(List.of("sub", "iss", "aud"))
                .build())
        .build();
```

--------------------------------

### JSON body after filtering

Source: https://github.com/zalando/logbook/blob/main/README.md

Example JSON body after applying the JSONPath filters. Sensitive fields are removed or replaced with placeholders.

```json
{
  "id": 1,
  "name": "Alice",
  "active": "unknown",
  "address": "XXX",
  "friends": [
    {
      "id": 2,
      "name": "B."
    },
    {
      "id": 3,
      "name": "C."
    }
  ],
  "grades": {
    "Math": 1.0,
    "English": 1.0,
    "Science": 1.0,
    "PE": 1.0
  }
}
```

--------------------------------

### Run LogbookBenchmark with Maven and Java

Source: https://github.com/zalando/logbook/blob/main/logbook-jmh/README.md

Command to build the project and execute the LogbookBenchmark, outputting results in JSON format. The resulting jmh-result.json can be viewed in a visualizer. Remember to disable CPU turbo/boost and close competing programs for accurate results.

```bash
mvn clean package && java -jar logbook-jmh/target/benchmark.jar LogbookBenchmark -rf json
```

--------------------------------

### DefaultSink constructor

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-core.md

Constructor for DefaultSink. isActive() delegates to writer.isActive(); write(pre, req) calls writer.write(pre, formatter.format(pre, req)); write(corr, req, res) calls writer.write(corr, formatter.format(corr, res)).

```java
public DefaultSink(final HttpLogFormatter formatter, final HttpLogWriter writer)
```

--------------------------------

### Configure HttpClient with LogbookHttpRequestInterceptor and LogbookHttpResponseInterceptor

Source: https://github.com/zalando/logbook/blob/main/README.md

Configures a synchronous HttpClient with Logbook request and response interceptors from the logbook-httpclient module.

```java
CloseableHttpClient client = HttpClientBuilder.create()
        .addInterceptorFirst(new LogbookHttpRequestInterceptor(logbook))
        .addInterceptorFirst(new LogbookHttpResponseInterceptor())
        .build();
```

--------------------------------

### Netty server handler usage in ChannelInitializer

Source: https://github.com/zalando/logbook/blob/main/_autodocs/api-reference/logbook-server-integrations.md

Example of adding the LogbookServerHandler to a Netty channel pipeline. The handler is added before codec and application handlers.

```java
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import org.zalando.logbook.Logbook;
import org.zalando.logbook.netty.LogbookServerHandler;

ChannelInitializer<SocketChannel> initializer = new ChannelInitializer<>() {
    @Override protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast("logbook", new LogbookServerHandler(Logbook.create()));
        // ... codec and application handlers after it
    }
};
```

--------------------------------

### Configure server and client predicates

Source: https://github.com/zalando/logbook/blob/main/README.md

Configures separate include predicates for incoming (server) and outgoing (client) requests. The global predicates apply to both directions; use these to filter differently when needed.

```yaml
logbook:
  server:
    predicate:
      include:
        - path: /api/**
        - path: /int/**
  client:
    predicate:
      include:
        - path: /**

```
Tokens:
Raw