Overview

With Live Debugger, you can debug running applications in real time, without redeploying code or interrupting service. Powered by Datadog’s Dynamic Instrumentation, Live Debugger uses logpoints—auto-expiring, “non-breaking breakpoints”—to collect information from running applications without pausing execution. This makes it ideal for investigating issues in environments where traditional debugging methods aren’t practical.

Key capabilities

Live Debugger provides:

• Real-time inspection of variable states, method arguments, and execution paths in running code.
• Non-invasive data collection that captures debugging information without stopping applications or degrading performance.
• Code instrumentation with logpoints that can be added anywhere in your code, including third-party libraries.
• Auto-expiring logpoints that are automatically deactivated after a set time (default: 48 hours).
• Conditional logging based on user-defined criteria to capture data only when specific conditions are met.
• Built-in sensitive data scrubbing to prevent exposure of personal information, passwords, and secrets.

Getting started

Prerequisites

1. All Dynamic Instrumentation prerequisites are met.
2. You have created a logs index to store debugging information.
3. (Recommended) You have enabled Source Code Integration to view and select specific code locations when adding logpoints.

Setup Live Debugger

Enable and disable Live Debugger on a service using one of the following methods:

One-click enablement (recommended)

1. Select the service and environment on the Live Debugger Settings page.
2. Check that all prerequisites are met as indicated on the Settings page.
3. Click “Enable” or “Disable”:
   • “Enable” to allow users to create Debug Sessions on the selected service and environment.
   • “Disable” to deactivate active Debug Sessions and prevent users from creating more.

Note: No service restart is required for changes to take effect. Admins and security contacts receive email notifications when services are enabled or disabled.

Manual enablement

1. Select the service and environment on the Live Debugger Settings page.
2. Follow the instructions to enable Live Debugger.
3. Restart the service before using Live Debugger.

Live Debugger and Dynamic Instrumentation

Due to shared underlying technology, Live Debugger and Dynamic Instrumentation are always enabled or disabled together on the same service and environment.

Like Live Debugger, Dynamic Instrumentation allows users to create logpoints (in addition to supporting other custom instrumentation like spans, span tags, and metrics). However, Live Debugger logpoints expire automatically after a set time period, while Dynamic Instrumentation logpoints remain active until manually deactivated.

When you enable or disable Live Debugger, the same action applies to Dynamic Instrumentation for that service and environment. When disabled, all data capture stops from both active Debug Session logpoints and dynamic instrumentations.

Using Live Debugger

Creating and using a Debug Session

Debug Sessions let you inspect your code at runtime with auto-expiring logpoints. To create and use a Debug Session:

1. Start a Debug Session from one of the following:
   • On the Live Debugger page, click Create Debug Session.
   • (Requires Code Origins feature) In the Trace Explorer, click on a trace to open the side panel, find the Code Origin section, and click Start Debug Session.
2. Add the first logpoint to start the session.
3. Add, remove, and modify logpoints within the session.

Debug Sessions automatically expire after 48 hours. You can manually disable and re-enable both sessions and individual logpoints at any time.

Creating logpoints

Logpoints are “non-breaking breakpoints” that specify where in the code to capture information, what data to include, and under what conditions. To add a logpoint for debugging:

1. Go to the Live Debugger page.
2. Click Create Debug Session.
3. Choose your service, environment, and select where in your code to place the first logpoint.
4. Define a logpoint message template using the Dynamic Instrumentation expression language.
5. (Optional) Enable “Capture Variables” to collect all execution context (this feature is rate-limited to 1 execution per second).
6. (Optional) Define a condition for when the logs should be emitted.

Note: Some feature limitations may apply depending on the service’s runtime language. Review the runtime language-specific documentation for more details.

Protecting sensitive data

Live Debugger data might contain sensitive information, especially when using the “Capture Variables” option. To protect this data:

1. Use the built-in sensitive data scrubbing mechanisms.
2. Use Sensitive Data Scanner to identify and redact sensitive information based on regular expressions.

Impact on performance and billing

Enabling Live Debugger and Dynamic Instrumentation on a service does not trigger data capture or impact performance. Data capture only occurs when there are active Debug Sessions or dynamic instrumentations on that service.

Performance impact: Datadog’s agent-driven instrumentation ensures minimal impact on application performance; sampling logic, rate limits, and built-in budgets prevent runaway data capture.

Pricing impact: Logs captured by Datadog are all billed the same way, whether they are generated from Live Debugger or logger lines in your source code. With Live Debugger, the logpoints automatically expire after the set time period, limiting unnecessary data accumulation and costs. Monitor your Datadog Plan & Usage page for any unexpected increases after utilizing a new feature.

Limitations

The following constraints apply to Live Debugger usage and configuration:

• Language support: Live Debugger is available for the same runtime languages as Dynamic Instrumentation, including: Java, Python, .NET, PHP (preview), Node.js (preview), Ruby (preview).
• Configuration scope: Live Debugger and Dynamic Instrumentation are enabled or disabled together for the same service and environment.
• Rate limits:
  • Logpoints with variable capture: Limited to 1 execution per second.
  • Logpoints without variable capture: Limited to 5000 executions per second, per service instance.
• Session duration: Debug Sessions automatically expire after 48 hours by default.

Further Reading

Additional helpful documentation, links, and articles:

Dynamic InstrumentationDOCUMENTATION Dynamic Instrumentation Expression LanguageDOCUMENTATION Sensitive Data ScrubbingDOCUMENTATION Autocomplete and Search (Preview)DOCUMENTATION Execution ReplayDOCUMENTATION