Skip to content

Hooks and logger

Hooks

Hooks observe every HTTP attempt (retries included) for metrics, auditing or debugging. All data they receive is already redacted: sensitive headers show [REDACTED] and the URL has its sensitive query values redacted. An exception thrown by a hook is caught and ignored, so hooks can never break a call.

Hook Data
onRequest RequestInfo { method, url, headers, attempt } (attempt starts at 1)
onResponse ResponseInfo { method, url, status, durationMs, attempt, requestId? }
onError ErrorInfo { method, url, error, attempt, willRetry }
const client = new DatadogApmClient({
  hooks: {
    onRequest: (r) => console.debug("->", r.method, r.url, "attempt", r.attempt),
    onResponse: (r) => metrics.observe(r.status, r.durationMs),
    onError: (e) => console.warn(e.error.code, "willRetry", e.willRetry),
  },
});
use std::sync::Arc;
use grow_datadog_apm::core::{ErrorInfo, Hooks, RequestInfo, ResponseInfo};

struct Metrics;

impl Hooks for Metrics {
    fn on_request(&self, r: &RequestInfo) {
        println!("-> {} {} attempt {}", r.method, r.url, r.attempt);
    }
    fn on_response(&self, r: &ResponseInfo) {
        println!("<- {} in {:?}", r.status, r.duration);
    }
    fn on_error(&self, e: &ErrorInfo) {
        eprintln!("{:?} will_retry={}", e.error.code(), e.will_retry);
    }
}

let config = DatadogApmConfig::builder().hooks(Arc::new(Metrics)).build()?;
cfg := datadogapm.Config{CommonConfig: datadogapm.CommonConfig{
    Hooks: &datadogapm.Hooks{
        OnRequest:  func(r datadogapm.RequestInfo) { log.Printf("-> %s %s attempt %d", r.Method, r.URL, r.Attempt) },
        OnResponse: func(r datadogapm.ResponseInfo) { log.Printf("<- %d in %s", r.Status, r.Duration) },
        OnError:    func(e datadogapm.ErrorInfo) { log.Printf("%v willRetry=%t", e.Err, e.WillRetry) },
    },
}}
from grow_datadog_apm import Hooks, DatadogApmConfig

config = DatadogApmConfig(
    hooks=Hooks(
        on_request=lambda r: print("->", r.method, r.url, "attempt", r.attempt),
        on_response=lambda r: print("<-", r.status, r.duration_ms),
        on_error=lambda e: print(type(e.error).__name__, "will_retry", e.will_retry),
    )
)
Hooks hooks = new Hooks() {
  @Override public void onRequest(Hooks.RequestInfo r) {
    System.out.println("-> " + r.method() + " " + r.url() + " attempt " + r.attempt());
  }
  @Override public void onResponse(Hooks.ResponseInfo r) {
    System.out.println("<- " + r.status() + " in " + r.durationMs() + " ms");
  }
  @Override public void onError(Hooks.ErrorInfo e) {
    System.out.println(e.error().code() + " willRetry=" + e.willRetry());
  }
};
DatadogApmConfig config = DatadogApmConfig.builder().hooks(hooks).build();

Logger

The client writes diagnostic messages (retries, TLS warnings, closed resources) to a logger. It is silent by default and never logs secrets.

Language Default How to enable
TypeScript silent logger: { debug, info, warn, error } in the config (for example console)
Rust tracing events at debug install a tracing subscriber in your application
Go *slog.Logger that discards CommonConfig.Logger: slog.Default()
Python logging.getLogger("grow_datadog_apm") with a NullHandler configure the grow_datadog_apm logger, or pass logger=
Java no-op (no SLF4J dependency) .logger(...) with an implementation of codes.grow.packages.datadogapm.core.Logger
const client = new DatadogApmClient({ logger: console });
tracing_subscriber::fmt().with_env_filter("grow_datadog_apm=debug").init();
cfg := datadogapm.Config{CommonConfig: datadogapm.CommonConfig{Logger: slog.Default()}}
import logging
logging.basicConfig()
logging.getLogger("grow_datadog_apm").setLevel(logging.DEBUG)
Logger stderr = new Logger() {
  @Override public void warn(String message, Map<String, Object> fields) {
    System.err.println(message + " " + fields);
  }
};
DatadogApmConfig config = DatadogApmConfig.builder().logger(stderr).build();