dynatrace-bridge-mcp
Allows AI assistants to query Dynatrace Managed observability data such as services, traces, metrics, pods, and problems through a logged-in browser session, using read-only GET requests to a fixed set of Dynatrace routes.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@dynatrace-bridge-mcp show me the current open problems in Dynatrace"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Dynatrace Bridge MCP
English | Türkçe
Let your AI assistant query Dynatrace Managed (services, traces, metrics, pods, problems) through your logged-in browser tab. No API tokens, and read-only by construction.

Dynatrace Managed clusters behind corporate SSO rarely hand out API tokens, and the public API answers 401 without one. Your browser session is the credential you already have. A small extension runs the requests inside your Dynatrace tab, and an MCP server turns the answers into compact text for Claude Code, Cursor, Codex or any other MCP client. The bridge can only send GET requests to a fixed list of Dynatrace routes, so it cannot change anything in your environment.

Setup
Takes about two minutes. Using an AI agent with a terminal? Let it do the setup.
1. Add it to your AI client
claude mcp add --scope user dynatrace-bridge-mcp -- npx -y dynatrace-bridge-mcp@latest--scope user makes it available in all your projects (leave it out to add it to the current project only). Your client starts the server by itself whenever it needs it, and @latest keeps it up to date.
JSON config (Claude Desktop, Cursor and most other clients):
{
"mcpServers": {
"dynatrace-bridge-mcp": {
"command": "npx",
"args": ["-y", "dynatrace-bridge-mcp@latest"]
}
}
}Config files: Claude Desktop ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows). Cursor ~/.cursor/mcp.json.
codex mcp add dynatrace-bridge-mcp -- npx -y dynatrace-bridge-mcp@latest
gemini mcp add dynatrace-bridge-mcp npx dynatrace-bridge-mcp@latest
code --add-mcp '{"name":"dynatrace-bridge-mcp","command":"npx","args":["-y","dynatrace-bridge-mcp@latest"]}'Windows: many clients can't find npx on their own, so run it through cmd /c. For example claude mcp add --scope user dynatrace-bridge-mcp -- cmd /c npx -y dynatrace-bridge-mcp@latest, or "command": "cmd", "args": ["/c", "npx", "-y", "dynatrace-bridge-mcp@latest"] in JSON.
Standalone server: run npx -y dynatrace-bridge-mcp@latest in a terminal and connect clients to http://localhost:47832/mcp (or /sse for older clients).
Several clients at once: the first instance owns the two ports. Every further instance started by another client forwards its tool calls to the first one, so all clients share one browser connection. When the first one goes away (its client was closed, for example), one of the others takes over the ports by itself within a few seconds and the rest follow it; nothing has to be reconnected.
2. Install the browser extension
npx -y dynatrace-bridge-mcp@latest install-extensionThis copies the extension to ~/.dynatrace-bridge/extension, puts that path on your clipboard and opens your browser's extensions page. There, turn on Developer mode, click Load unpacked and paste the path.
Works in Chrome, Edge, Brave, Arc, Vivaldi, Opera and other Chromium browsers (not Firefox or Safari). Install it in the browser where you are logged in to Dynatrace.

In Edge, Developer mode is in the left sidebar. In the folder picker, press ⌘⇧G on macOS or use the address bar on Windows to paste the path. Add --browser brave (or chrome, edge, arc, vivaldi, opera, chromium) to the command to pick a browser other than your default, or --lang tr|en to set the output language.
3. Add your environment
Open Dynatrace (a URL that contains /e/<environment id>/), log in, click the extension icon and press Add this environment. Chrome then asks whether the extension may access that site; allow it. The extension has no access to any site until you add one, and it only ever asks for the Dynatrace origin you are on.
The environment gets a short name (the environment id, or its last dash-separated part: acme-shop-s1 becomes s1). Click the name to rename it; the AI selects the environment by this name. Repeat for other environments (stage, prod, …). The first one is the default.
A small pill then appears in the bottom right corner of your Dynatrace tabs. It shows whether the AI is connected and what it is asking for while it works. Click its dot to collapse it.
You don't have to keep Dynatrace in front. The bridge uses an open Dynatrace tab in the background, without focusing it. If no tab is open, it opens one in front of you, so that you can log in if Dynatrace asks.
4. Try it
Which services got slower in the last two hours? Pick the worst one and tell me where its time goes.
Updating
The server updates by itself: @latest makes your client start the newest version the next time it starts. When the extension falls behind the server, you are told in three places: the extension popup, the pill in the Dynatrace tab, and a note at the end of the AI's tool results. Re-run the install-extension command, then click reload ↻ on Dynatrace Bridge in the extensions page.
The same places tell you to restart your AI client when the running server is older than the extension, or when a newer release exists on npm.
Related MCP server: Dynatrace SaaS MCP Server
Let your AI do the setup
Paste this into Claude Code, Codex, Cursor or any agent with a terminal:
Set up dynatrace-bridge-mcp for me by following https://github.com/yunusemregul/dynatrace-bridge-mcp#for-ai-agents
For AI agents
You can run steps 1 and 2. The browser steps need the user, because browsers don't let scripts enable Developer mode, load extensions or grant site access.
Check
node --versionis 18 or newer, then register the server with the client you're running in (commands; use thecmd /cform on Windows).Run
npx -y dynatrace-bridge-mcp@latest install-extension. It prints the folder path (--no-openskips opening the browser,--no-copyleaves the clipboard alone,--browser <name>picks a browser).Ask the user to turn on Developer mode, click Load unpacked and paste that path. Wait for them to confirm.
Ask the user to open Dynatrace, log in, click the Dynatrace Bridge icon (in the puzzle-piece menu if not pinned), press Add this environment and allow site access in the browser prompt.
Ask the user to restart the client or reconnect MCP servers (
/mcpin Claude Code) so the tools load.Verify with
curl -s http://localhost:47832/health. You want"connected":trueand at least one name in"environments". No answer means the client hasn't started the server yet. Finish withdynatrace_bridge_status(passcheck_session: trueto test the login as well).
What to ask
Ask | Tools the AI reaches for |
"Which endpoints are the slowest?" |
|
"Which endpoints use the most CPU / fail the most?" |
|
"Why is the checkout service failing?" |
|
"Where does this service spend its time?" |
|
"Which SQL is slow, and who runs it?" |
|
"Which cron jobs take the longest?" |
|
"Why does this pod restart? Was it OOM-killed?" |
|
"What happened in problem P-12345?" |
|
"Show me slow traces of |
|
Tools
39 tools, listed in the order the server presents them.
Start here: status, entities, metrics
Tool | What it does |
| Server and extension versions, connected browsers, configured environments; optionally checks each login. |
| Finds entities of any type by name or entity selector and returns their ids. |
| One entity in full: properties, tags, management zones, relationships. |
| Searches the metric catalogue for ids, units and dimensions. |
| Runs any metric selector and summarises each series (min, avg, max, trend, values over time). |
Services, events, problems
Tool | What it does |
| Services with response time, failure rate and throughput; sortable. |
| One service: percentiles, failures, throughput, callers and callees, hosts and pods, problems. |
| Deployments, restarts, Kubernetes and anomaly events, identical ones collapsed. |
| Problems active in the window, filterable by status, impact, severity and entity. |
| One problem as a compact overview: evidence by entity, root cause findings, impact, trigger event, affected requests, dependency path; |
Kubernetes, hosts, processes
Tool | What it does |
| Workloads with running and desired pods, CPU and memory against requests and limits. |
| Pods of a workload with phase, node, restarts, requests and limits, containers. |
| CPU, throttling, memory, OOM kills and restarts per pod and container over time. |
| Kubernetes events of a workload's pods: probe failures, kills, scheduling, deploys. |
| JVM heap and GC or Node.js heap and event loop metrics of the processes in a pod. |
| One host: hardware, availability, CPU, memory, disks, processes, events. |
| One process or process group: technology, where it runs, services, callers and callees. |
Traces
Tool | What it does |
| Endpoints of a service, SQL statements of a database service, or target hosts of an "unmonitored hosts" service, with metrics. |
| Single traces of a service or the whole environment, filtered by response time, HTTP code, failure, method, request or URL. |
| Any trace metric split by any dimension (multidimensional analysis), with the same filters. |
| One trace as a span tree with timings, SQL and downstream calls. |
| One call of a trace: exceptions with stack traces, method tree, SQL text, headers, host or pod. |
Service analysis, cron jobs, database
Tool | What it does |
| Why requests of a service fail: reasons, exceptions, failed downstream calls. |
| Where the response time goes (code, downstream, database) and how it is distributed. |
| What a service calls, as a tree with each dependency's contribution. |
| Who calls a service, up to the entry requests and jobs. |
| Exception classes by count, across services or for one. |
| Cron jobs by total time, average, longest run, executions and failures. |
| SQL statements of a database service by total time, average, max or executions; database services that share a name are combined. |
| Which services, requests and jobs execute one SQL statement. |
| Slow executions of one statement with the traces they belong to. |
Profiling
Tool | What it does |
| Process groups by CPU time. |
| Hot methods of a service or process group from code-level samples. |
| Thread groups of a process group by state and CPU. |
| Where a Java process group allocates memory. |
| Process crashes in the window. |
Dashboards and settings
Tool | What it does |
| Dashboards visible to you. |
| Tiles of a dashboard and the metric selectors behind its charts. |
| Reads settings schemas and their values (alerting, anomaly detection, request attributes, …). |
Results are compact text sized for an AI's context: a header stating what was queried and the exact UTC window, tables with the ids the next tool needs, a hint on what to call next, and a link to the matching Dynatrace page. Charts come back as summarised series, not as images.
environment: which configured environment to query, by the name shown in the popup. Defaults to the first one.minutes_lookback,time_from,time_to: the time window. The default is the last 120 minutes. Timestamps are ISO 8601 and are read as UTC when they carry no zone.get_problem,find_metrics,list_dashboardsandread_settingshave no time window.Entities (
service,workload,pod,host, …) can be passed as an id or as a name. An ambiguous name returns the candidates with their ids instead of a guess.Trace filters, shared by the trace and service analysis tools:
response_time_min_ms,response_time_max_ms,http_code(404,4xx,400-599),failed,http_method,request,url_contains,request_kind(webordatabase).limit: how many rows are printed. The output says how many were left out.
Troubleshooting
Problem | Fix |
The extension icon shows OFF, the popup says "Not running" | The MCP server isn't running. It starts with your AI client, so open the client (or reconnect its MCP servers). If you changed |
"No browser extension is connected" | Open the browser where the extension is installed and check that it is enabled and its popup says Connected. |
"Dynatrace needs a login" and a Dynatrace tab opens in front | Your session expired. Log in to Dynatrace in that tab (the bridge never enters credentials), then ask again. |
The popup says "The active tab is not a Dynatrace environment page" | The tab's URL must contain |
"No Dynatrace environment is configured" | Open Dynatrace and press Add this environment in the popup. |
"The extension has no site access to …" | Site access was revoked in the browser. Remove the environment in the popup and add it again. |
"… more data than the bridge relays" (response too large) | The answer exceeded the size limit (32 MiB by default). Ask for a shorter time window or narrower filters. |
"An extension at chrome-extension://… tried to connect and was refused" | The server only accepts the extension build it ships. Re-run |
"Port 47831 (or 47832) is in use by another program" | Free the port or set |
"HTTP 403 … lacks the permission" | Your Dynatrace user may not read that data. The bridge has exactly your permissions. |
"Dynatrace's internal API changed" | A cluster upgrade changed an undocumented endpoint. Please open an issue with the tool name and your cluster version. |
Configuration
You don't need this for normal use.
Set these in the env block of your MCP client config.
Variable | Default | Purpose |
|
| HTTP port for MCP clients ( |
|
| WebSocket port for the extension (also change it behind the ⚙ in the popup) |
|
| Bind address of both ports |
|
| How long a tool call waits for the extension to connect before it fails |
| on |
|
|
| Where the version check looks, for a registry mirror |
| empty | Web origins that may call the HTTP port, comma- or space-separated. Only for a browser-based MCP client |
| empty | Extra extension origins that may connect to the WebSocket, e.g. |
| version of the package | Overrides the version the server reports to the extension. For trying out the update notices |
Freeing a port: lsof -ti:47831 | xargs kill on macOS / Linux, or netstat -ano | findstr :47831 then taskkill /PID <pid> /F on Windows.
Security
Your session, your permissions. Requests run inside your Dynatrace tab with your login. The bridge sees what you can see and nothing more. The CSRF token is read in the page for each request and never leaves it; neither it nor your cookies are logged or sent to the server.
Read-only by construction. Only
GETis possible, there is no way to send a request body, and the path must be one of the exact routes the tools use. Anything else is refused, and paths that containapiTokens,credentials,tokensor memory dumps are always refused. The rule is enforced three times: in the server before sending, in the extension, and again in the page.Site access only where you grant it. The extension installs without access to any site and asks for one Dynatrace origin at a time when you add an environment. Removing the last environment of an origin gives the access back.
The HTTP port is loopback-only. It binds to
127.0.0.1, requires a loopbackHostheader, and refuses any request that carries a browserOriginunless you allow that origin, so a web page cannot call it. It has no authentication of its own, so don't expose it to other machines.The WebSocket is pinned to the extension. The server accepts a connection only from the extension id it ships (
nnfgclefihmkappeocegckipegkalloe). Web pages and other extensions are refused.Tool output is scrubbed. Authorization, cookie and CSRF headers are dropped, and token-shaped values and values of secret-looking names are masked before anything reaches the AI.
Known limitation. The extension connects to whatever listens on
localhost:47831. A local process that takes that port before the server does receives the extension's connection and can send it read-only requests from the allowed list. Closing this would need a pairing secret, which this project does not have.One outbound request. The server asks the npm registry for the latest version of this package at startup and then once every 24 hours, to tell you about updates. Nothing else leaves your machine besides the requests to your own Dynatrace. Turn it off with
DT_BRIDGE_UPDATE_CHECK=0.
Limitations
Dynatrace Managed, classic UI. Environments are recognised by
/e/<environment id>/in the URL. Dynatrace SaaS with the latest (Grail) UI uses different APIs and is not supported.Verified on version 1.346 only. Traces, service analysis, database, profiling and the Davis details of a problem come from the internal endpoints behind the Dynatrace UI. They are undocumented and can change with a cluster upgrade; the tools check the response shape and say so when it no longer matches. Entities, metrics, problems, events and the Kubernetes tools use the session mirror of the documented API v2 and are less exposed to that.
No logs. There are no log tools. The environment this was built against does not grant log access to UI users, so nothing could be built or checked.
Sampling and retention apply. Dynatrace keeps and samples traces as configured on your cluster; the tools pass on the warnings Dynatrace attaches.
Mind your operator. The bridge uses your UI session against endpoints meant for the UI. It runs analysis requests one at a time per environment, but whether this use is welcome on your cluster is for you and its operator to decide.
Not an official Dynatrace product. This project is not affiliated with or endorsed by Dynatrace.
Development
git clone https://github.com/yunusemregul/dynatrace-bridge-mcp.git
cd dynatrace-bridge-mcp
npm install
npm run verifynpm run verify is the build check, and the only one: there is no test suite. It checks syntax, the version sync between package.json and the extension manifest, the pinned extension id, the translations, that the server-side and extension-side allow-lists agree on every case, the installer, and a real server start with its HTTP and WebSocket gates. It never opens a browser and never contacts Dynatrace. CI runs it on every push to main and on every pull request.
Plain JavaScript (ESM), Node 18 or newer, no build step. To work on the extension, load the repository's extension/ folder with Load unpacked. ARCHITECTURE.md describes the protocol, the allow-list and how to write a tool.
License
Available Tools
39 toolsanalyze_failuresA
Explains why requests of a service fail in a time window (Dynatrace failure analysis): the failure reasons ranked by failed requests, each with its type, HTTP status, share of all failures, the exception classes and messages behind it (with the top stack frames), failed downstream calls, and the requests it affects.
Start here for "why does this service fail": use it when a service shows a failure rate or a problem names it. Pass service as an id or a name. The shared trace filters (response_time_min_ms, response_time_max_ms, http_code, failed, http_method, request, request_group_id, url_contains, request_kind, raw_filters) narrow the analysed requests.
Follow up with list_traces (failed: true, optionally http_code) for the individual failing traces, or top_exceptions for exception counts.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: service (required), limit, failed, request, +14 more.
analyze_response_timeA
Shows where the response time of a service goes and how it is distributed (Dynatrace response time analysis). Part 1, hotspots: average response time split into own code, calls to other services and database calls; code execution time by state (CPU, wait, lock, network and disk I/O, suspension); every downstream service and database with its contribution, call frequency and call time; and the single downstream requests / SQL statements that cost the most. Part 2, distribution: a text histogram of response times including failed requests, with the outlier tail called out.
Start here for "why is this service (or one of its endpoints) slow". Pass service as an id or a name. The shared trace filters (response_time_min_ms, response_time_max_ms, http_code, failed, http_method, request, request_group_id, url_contains, request_kind, raw_filters) narrow the analysed requests. E.g. response_time_min_ms: 2000 analyses only the slow requests, request one endpoint.
It runs two analysis requests, one after the other. Follow up with service_flow for the full downstream tree, top_database_statements on a database listed here, method_hotspots for own-code time, or list_traces with response_time_min_ms for the outliers.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: service (required), limit, failed, request, +13 more.
cpu_by_process_groupA
Lists the process groups that consumed the most CPU in the window (Dynatrace continuous CPU profiling): CPU time, share of the total, CPU time spent in garbage collection, when the peak was, and which deeper analyses each process group supports.
Start here for "which process burns the CPU". Follow up with method_hotspots (hot methods), thread_analysis (thread groups and states) or memory_allocation_hotspots, passing the PROCESS_GROUP id from the table as process_group. For CPU per endpoint use trace_statistics with metric: "CPU_TIME".
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: text, limit, time_to, time_from, +2 more.
cron_job_statisticsA
Ranks cron jobs by how much time they take: per job the number of executions, failed runs, total time, average and longest run and CPU time, with the service and request ids needed to open single runs. The tool for "which cron jobs are the slowest / the most time-consuming / fail".
It reads the requests of the service whose requests are the cron jobs. SAP Commerce (hybris) environments have such a service named CronJobs, the default for service; Dynatrace usually has several services with that name (one per process group or node), and this tool combines all of them, which a single list_service_requests call cannot. Pass another service name or one SERVICE id as service when the jobs live elsewhere. When no such service exists the tool says so and names the alternatives.
The default window is the last 24 hours. sort: total_time (default), avg, max, executions, failures, cpu. name keeps jobs whose name contains the text; response_time_min_ms and failed count only the long or the failed runs. A run is one trace and is counted with its full duration (verified for runs of over an hour); runs still executing at the end of the window may be missing. A row named after a method instead of a job (ServicelayerJob.performCronJob) collects the runs Dynatrace could not name; the output marks it.
Follow up with list_traces (service and request from the last column) for the single runs, then get_trace for what a run did.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: name, sort, limit, failed, +8 more.
dynatrace_bridge_statusA
Reports whether the Dynatrace Bridge is usable: server version and whether a newer release exists, whether the browser extension is connected and its version (each browser when several are connected), and the Dynatrace environments configured in the extension (name, environment id, URL).
Call this first when another Dynatrace tool fails with a connection, environment or session error, or when the user asks which environments are available. Works even when no extension is connected.
Pass check_session: true to also run one small request per environment and see whether the browser is still logged in.
Where to start with the other tools. All take environment. All except get_problem, find_metrics, list_dashboards and read_settings also take the time arguments minutes_lookback / time_from / time_to (timestamps without a zone are read as UTC); those four have no time window.
An incident, or "what is wrong":
list_problems, thenget_problemwith the P- id.A slow or failing service:
list_services(sort: "response_time"or"failure_rate") to find it,service_overview, thenanalyze_response_timeoranalyze_failures, thenlist_tracesandget_tracefor single requests.Across all services,
trace_statisticswithrequest_kind: "web"and: slowest endpointsaggregation: "P95"(or"AVERAGE") plusmin_calls: 20; most time-consuming endpointsaggregation: "SUM"; most CPUmetric: "CPU_TIME",aggregation: "SUM"; most errorsmetric: "FAILED_REQUEST_COUNT"(a count metric, ranked by itsCOUNT).Exceptions:
top_exceptions. Slow or expensive SQL:top_database_statements. Slow or long-running cron jobs:cron_job_statistics.Pod restarts, OOM kills, throttling:
list_workloads, thenpod_resourcesandpod_events. CPU or memory of a process:cpu_by_process_group,method_hotspots,process_runtime.Anything else:
find_entitiesfor ids,find_metricsandquery_metricsfor the data behind any chart.
Inputs: check_session.
find_entitiesA
Searches Dynatrace monitored entities of any type and returns their ids and names. Use it to turn a name the user mentions into the entity id that other tools need, or to list what exists (services, hosts, process groups, Kubernetes workloads, pods, containers, queues, …).
Give type (e.g. SERVICE, HOST, PROCESS_GROUP, PROCESS_GROUP_INSTANCE, CLOUD_APPLICATION (Kubernetes workload), CLOUD_APPLICATION_INSTANCE (pod), CONTAINER_GROUP_INSTANCE (container), KUBERNETES_CLUSTER, KUBERNETES_NODE, QUEUE) and optionally name (case-insensitive substring). For anything more specific pass a full Dynatrace selector (entitySelector syntax), e.g. type(CLOUD_APPLICATION_INSTANCE),fromRelationships.isInstanceOf(entityId("CLOUD_APPLICATION-1234567890ABCDEF")) for the pods of a workload, or type(SERVICE),tag("team:checkout").
Called with neither type nor selector, it lists the entity types that exist in the environment.
Only entities seen inside the time window are returned. Add fields (e.g. tags, managementZones, properties.cloudApplicationInstancePhase, fromRelationships.runsOn) for extra columns. Follow up with get_entity for all properties and relationships of one entity.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: name, type, limit, fields, +5 more.
find_metricsA
Searches the Dynatrace metric catalogue and returns metric ids with unit, available aggregations, dimensions and the entity types they apply to. Use it before query_metrics whenever you are not sure of the exact metric id.
Pass text for a free-text search over id, name and description (e.g. "response time", "container memory", "v8 heap"), and/or selector for an id pattern with a trailing wildcard (e.g. builtin:service.*, builtin:containers.cpu.*, builtin:kubernetes.workload.*, builtin:tech.jvm.*, builtin:tech.nodejs.*).
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: text, limit, describe, selector, +1 more.
get_dashboardA
Shows one Dynatrace dashboard: owner, tags and every tile with its type and title, and for chart (Data Explorer) tiles the metric selectors behind them, so the same data can be read with query_metrics.
dashboard is an id from list_dashboards or a name (an ambiguous name returns the candidates). Reading the queries of a chart tile costs one request to Dynatrace per tile, so only the first tile_details chart tiles (12 by default, at most 30) get their queries; the others are listed without them, and the output names the tile ids to pass as tile to read those next. run_queries: true executes up to max_queries of the tile selectors over the time window and prints each as summarised series.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: dashboard (required), tile, limit, time_to, +6 more.
get_entityA
Returns one Dynatrace entity in full: type, first/last seen, tags, management zones, all properties (for pods: phase, node, restarts, requests/limits; for services: technology, type; for hosts: OS, CPU, memory, …) and its relationships to other entities with their ids and names (runs on, calls, called by, is instance of, …).
Pass entity as an id (e.g. SERVICE-1234567890ABCDEF) or as a name together with type. An ambiguous name returns the candidates. Use the related ids with get_entity again to walk the topology, or in query_metrics entity selectors.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: entity (required), type, time_to, time_from, +3 more.
get_hostA
Returns one host in detail: OS, CPU cores and memory, IPs, monitoring mode, availability and downtimes, open problems; CPU and memory usage over the window as summarised series and disk usage per disk; the processes running on it with their technology, status, CPU and memory use; and its recent events.
Pass host as a HOST id or a host name (an ambiguous name returns the candidates). Kubernetes nodes are hosts too: the node name from list_pods works here. Follow up with get_process on a process id, or query_metrics with entity_selector: entityId("<host id>") for any other builtin:host.* metric.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: host (required), time_to, time_from, environment, +2 more.
get_problemA
Returns one Dynatrace problem. The default output is a compact overview: status, severity, start, end and duration; root cause entity, affected and impacted entities; the evidence grouped by entity with counts and the most relevant items; the impact; the Davis root-cause findings per candidate entity with the metric and event names; the event that triggered the problem with its baseline values; the most affected requests per service with their SERVICE_METHOD ids; and the entities on the dependency path Davis analysed that are affected, root cause or have events.
Pass problem as the display id (P-12345) or the internal problem id from list_problems. For the long form of one section pass detail: evidence (every evidence row), impact, davis (all candidates and findings), requests (the affected requests of every service) or path (the whole dependency path with event times). The Davis findings, trigger event and dependency path come from internal Dynatrace endpoints; if one of them is unavailable the rest is still returned with a note.
The result ends with the affected service id and the problem window to pass to analyze_failures and list_traces.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: problem (required), limit, detail, environment.
get_processA
Returns one process (PROCESS_GROUP_INSTANCE) or one process group (PROCESS_GROUP) in detail: technology and version, the host, pod, container and workload it runs in, the services it hosts, the processes that call it and that it calls, CPU and memory use over the window, and its events.
Pass process as a PROCESS_GROUP_INSTANCE id, a PROCESS_GROUP id, or a name (an ambiguous name returns the candidates with their ids). Process ids come from get_host, process_runtime or find_entities. Follow up with process_runtime for JVM / Node.js metrics, or the service tools with a service id from the list.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: process (required), time_to, time_from, environment, +1 more.
get_traceA
Shows one trace as an indented span tree: for every call the service, the operation (request name or SQL statement), how often it ran, its start offset from the beginning of the trace, response time, self time, CPU / wait / suspension time, the technology, and the callURI of the node.
Pass trace_id and call_uri exactly as printed by list_traces, with a time window that contains the trace (the same window is fine). Runs of identical sibling calls (the same SQL statement 200 times) are collapsed into one line with the call count and total time.
Large traces: min_duration_ms hides calls shorter than that, max_depth limits the nesting, limit caps the lines; the output always says what was hidden.
Follow up with get_trace_details on a node's callURI for exceptions with stack traces, the code-level method tree, full SQL and HTTP headers.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: call_uri (required), trace_id (required), limit, time_to, +5 more.
get_trace_detailsA
Everything Dynatrace recorded about one call (node) of a trace: exceptions with stack traces (identical ones grouped into one entry with a count), the code-level method tree with total / self / CPU / wait time pruned to the hot paths, the downstream calls it made with SQL text and call counts, the full SQL of a database call, HTTP request and response headers and parameters, the process and host / pod it ran on, and the technologies involved.
Pass call_uri of a node as printed by get_trace (or by list_traces for the entry call), with a time window that contains the trace.
Stack traces show the top stack_frames frames (full_stack: true for all) of the exception_limit most frequent distinct exceptions. Every section has its own share of the output, so a long one cannot crowd out the others. The method tree hides methods below min_method_ms (default 1 % of the call) and pass-through frames, and says how many. Authorization, cookie and token headers are never shown; request parameters, headers and attributes whose name looks like a secret (password, token, key, session id, …) or whose value looks like a credential are printed as <masked>, as are such parameters inside URLs; ordinary parameters are shown as Dynatrace stored them (Dynatrace itself may already have replaced values by <masked>).
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: call_uri (required), limit, time_to, time_from, +7 more.
list_dashboardsA
Lists the Dynatrace dashboards visible to the user: id, name, owner, last modification and tags. Filter with text (matches name, owner and tags).
Follow up with get_dashboard (id or name) to see the tiles and the metric selectors behind the charts.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: text, limit, environment.
list_eventsA
Lists Dynatrace events in a time window: deployments, process restarts, Kubernetes events (probe failures, kills, scheduling), availability and anomaly events (error rate or response time increase, CPU saturation), custom info and annotations. Identical events (same type, title, entity and Kubernetes reason) are collapsed into one row with a count and the first and last time, so a flapping probe is one line.
Scope it with entity_selector (entitySelector syntax, e.g. entityId("SERVICE-1234567890ABCDEF"), type(CLOUD_APPLICATION_INSTANCE),fromRelationships.isInstanceOf(entityId("CLOUD_APPLICATION-1234567890ABCDEF")) for the pods of a workload, type(HOST)), event_type (e.g. CUSTOM_DEPLOYMENT, PROCESS_RESTART, SERVICE_ERROR_RATE_INCREASED, CUSTOM_INFO) and status (open / closed). event_selector takes a raw Dynatrace eventSelector instead, e.g. property.dt.kubernetes.event.reason("Unhealthy"). Without any filter it lists every event of the environment in the window.
Use it to answer "what changed" around the time something broke; then get_entity or service_overview on an entity id, or list_problems for the same window.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: limit, status, time_to, time_from, +5 more.
list_podsA
Lists Kubernetes pods (Dynatrace entity type CLOUD_APPLICATION_INSTANCE) of a workload, or pods matching a name, with phase, node, IPs, restart count, age, CPU / memory requests and limits, and the containers in each pod with their ids.
Pass workload (id or name, from list_workloads) and/or name (substring of the pod name). Follow up with pod_resources for usage over time, pod_events for Kubernetes events, or process_runtime with a pod id for JVM / Node.js metrics.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: name, limit, time_to, workload, +3 more.
list_problemsA
Lists the problems Dynatrace (Davis) raised that were active in the time window: display id (P-…), internal problem id, title, severity, impact level, status, start, end, duration, root cause entity and how many entities were affected and impacted.
Filter by status (open / closed / all), impact_level (SERVICES, INFRASTRUCTURE, APPLICATION, ENVIRONMENT), severity (AVAILABILITY, ERROR, PERFORMANCE, RESOURCE_CONTENTION, CUSTOM_ALERT, …), entity_selector (e.g. entityId("SERVICE-1234567890ABCDEF") or type(HOST)) and text (case-insensitive, matched against id, title and entity names). An open problem that started before the window is included.
Start here for "what is wrong right now" or "what happened at that time". Follow up with get_problem (pass the P- id) for evidence, Davis root cause and the dependency path.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: text, limit, status, time_to, +6 more.
list_process_crashesA
Lists the process crashes Dynatrace detected in the window: time, crashed process, host or pod, and the signal or exception, with entity ids for follow-up. The field layout of this internal endpoint is not verified: the columns are matched by field name, and every field that was not recognised is printed under details, so nothing is hidden.
Use it when a service became unavailable, a pod restarted, or a problem mentions a crash. Follow up with get_process / get_host on the ids, pod_events for Kubernetes restarts, or list_problems for the same window.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: text, limit, time_to, time_from, +2 more.
list_service_requestsA
Lists what one service does, with metrics per row: call count, average / median / p90 / max response time, total time, failure rate and HTTP 4xx / 5xx counts. For a web or method service the rows are its requests (endpoints, jobs); for a database service they are its SQL statements; for a "Requests to unmonitored hosts" service they are the target hosts.
Use it to see which endpoint of a service is slow (sort: "avg" or "p90"), costs the most time ("total_time", the default), is called most ("calls") or fails ("failure_rate"). For the same question across all services use trace_statistics; for cron jobs cron_job_statistics.
Every row prints its id and name; the other tools take either one as request. The shared filter arguments narrow the requests that are counted, e.g. response_time_min_ms: 2000 or failed: true.
service is an id or a name; find services with list_services.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: service (required), sort, limit, failed, +14 more.
list_servicesA
Lists the services Dynatrace monitors with their key numbers for the time window: average and p90 response time, failure rate, request count and requests per minute. Use it to find a service id, to see which services are slow, failing or busy, and as the starting point of any service investigation.
Filter with name (case-insensitive substring), service_type (WEB_REQUEST_SERVICE, WEB_SERVICE, DATABASE_SERVICE, BACKGROUND_ACTIVITY, CUSTOM_SERVICE, …; a part such as "database" is enough), technology (Java, Node JS, Nginx, Apache, SQL Server, …) and tag (exactly as Dynatrace shows it, case-sensitive: key:value, or key for a tag without a value). sort picks the ranking: throughput (default), response_time, p90, failure_rate (all highest first) or name.
Start here for "which services are slow / failing / busy": sort: "response_time", "failure_rate" or "throughput". Several services can share one name (one per process group); the ids tell them apart. Follow up with service_overview for one service.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: tag, name, sort, limit, +6 more.
list_tracesA
Lists individual traces (PurePaths): the requests of one service, or of the whole environment when service is omitted. Use it to find concrete slow or failed requests, then open one with get_trace.
Filters: response time range, HTTP code or class, failed state, HTTP method, one request (request: name or id, with service), a request group, URL text (url_contains, web requests only, works without service), request kind, plus raw_filters.
Per trace: start time, request name, method + URL, HTTP code, failed flag, response / CPU / wait / suspension time, database call count and time, downstream service calls, exception classes, request attributes (secret-looking ones masked), and the traceId + callURI that get_trace needs.
Dynatrace returns the newest matching traces (fetch_limit of them, 100 by default, at most 3000); this tool then sorts those and prints limit of them (25 by default, at most 100). So "slowest" means the slowest among the fetched newest traces: when the output says Dynatrace returned its limit, narrow the window or the filters (e.g. response_time_min_ms) or raise fetch_limit. Default order: slowest first when a response time filter is given, newest first otherwise. A warning line appears when the window is only partly covered or traces are sampled.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: sort, limit, failed, request, +15 more.
list_workloadsA
Lists Kubernetes workloads (deployments, stateful sets, daemon sets, jobs; Dynatrace entity type CLOUD_APPLICATION) with workload type, namespace, cluster, running versus desired pods, and average CPU and memory usage against the configured requests and limits over the window.
Filter with name (case-insensitive substring), namespace (exact) and cluster (cluster name or KUBERNETES_CLUSTER id). Use it to find the workload id that list_pods, pod_resources, pod_events and process_runtime take, or to spot workloads running close to their limits.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: name, limit, cluster, time_to, +4 more.
memory_allocation_hotspotsA
Shows where a process group allocates memory (Dynatrace continuous memory profiling, Java): total allocated and surviving bytes, allocation per API, the methods that allocate the most with their main callers and object types, and the most allocated types.
Use it for high garbage-collection time or memory growth. survivors_only: true restricts to objects that survived a garbage collection (candidates for leaks and heap growth).
The default window is the last 15 minutes because Dynatrace answers with a very large call tree for busy process groups; keep the window short.
When memory profiling is not enabled or not supported for the process group, or the answer is too large to relay, the tool says so and what to do. cpu_by_process_group lists memory for the process groups that support it.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: process_group (required), limit, time_to, time_from, +3 more.
method_hotspotsA
Shows which methods a service or process group spends its time in, from Dynatrace code-level stack samples: sample share per API (framework / library group) and per thread state, then the hot methods.
view: "flat" (default) ranks methods by self share (samples where the method itself was on top of the stack) and also gives the total share including callees. view: "tree" prints the call tree from the thread entry points downwards, pruned to branches above min_share_percent.
By default only active states are counted (running on CPU, locking, network and disk I/O); include_waiting: true adds waiting threads.
Pass exactly one of service or process_group (id or name; ids come from list_services, trace_statistics or cpu_by_process_group). Numbers are stack samples, not milliseconds; compare shares. Follow up with thread_analysis for the thread groups behind the samples.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: text, view, limit, service, +7 more.
pod_eventsA
Lists the Kubernetes events Dynatrace recorded for the pods of a workload and for the workload itself (or for one pod): readiness / liveness probe failures, container kills and back-offs, scheduling and image pull problems, mount failures, deployment spec changes. Identical events are collapsed by reason and message, with a count and the first and last time, newest first.
Pass exactly one of workload or pod (id or name). Use it after pod_resources shows restarts, OOM kills or a pod that is not running, with the window narrowed to that time.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: pod, limit, time_to, workload, +3 more.
pod_resourcesA
Shows the resource behaviour of the pods of a Kubernetes workload, or of one pod, over the time window: CPU usage, CPU throttling, memory (resident set per container, working set for the workload, usage in % of the limit), OOM kills and container restarts, per pod and per container, each as a summarised series (min / avg / max with its time / last / trend and a compact table over time).
Start here for "why does this pod restart / get OOM-killed / run slow": it opens with findings that flag obvious trouble: usage near the limit, significant CPU throttling, OOM kills, restarts inside the window, pods not running. Pass exactly one of workload or pod (id or name; find workloads with list_workloads). Narrow the window around a peak with time_from / time_to, then check pod_events for what Kubernetes did at that time and process_runtime for the JVM / Node.js view.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: pod, time_to, workload, time_from, +3 more.
process_runtimeA
Reports runtime metrics of the processes (Dynatrace PROCESS_GROUP_INSTANCE) running in a pod, a workload or a process group, or of one process. The technology is detected per process: JVM processes get heap usage, heap max, memory pools, GC suspension and GC time, and thread count; Node.js processes get V8 heap used / total, RSS, event loop utilization and latency; every process gets CPU usage and working set memory. Each metric is a summarised series (min / avg / max with its time / last / trend, and a table over time for the main ones).
Pass exactly one of pod, workload, process_group or process (id or name). Use it when pod_resources shows memory growth or CPU saturation and you need to know whether heap, GC or the event loop is the cause. Follow up with get_process for callers, callees and hosted services.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: pod, process, time_to, workload, +5 more.
query_metricsA
Runs a Dynatrace metric query (the data behind any chart) and returns each series summarised: min, avg, max with its timestamp, last value, trend, and a compact table of values over time. Values are converted to readable units (µs → ms/s, bytes → MiB/GiB) from the unit of the metric descriptor; when Dynatrace names no unit, or the descriptor cannot be read, the values are printed raw and the output says so. The descriptor describes the plain metric, so after a transformation that changes the unit (:rate, :count, arithmetic) read the numbers with that in mind.
selector uses the Dynatrace metric selector language: a metric id plus optional transformations, e.g.
builtin:service.response.time:percentile(95)builtin:service.errors.total.rate:splitBy("dt.entity.service"):sort(value(avg,descending)):limit(10):namesbuiltin:containers.memory.residentSetBytes:splitBy("dt.entity.container_group_instance"):max:namesSeveral selectors can be given comma-separated. Append:namesso entity names are shown next to their ids. Find metric ids withfind_metrics.
Scope to entities with entity_selector (entitySelector syntax), e.g. entityId("SERVICE-1234567890ABCDEF") or type(HOST),entityName.contains("web"). resolution sets the point spacing (1m, 5m, 1h, 1d, or Inf for a single value over the window); by default Dynatrace picks one that fits the window.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: selector (required), time_to, time_from, max_series, +4 more.
read_settingsA
Reads Dynatrace configuration (Settings 2.0), read-only: alerting profiles, anomaly detection thresholds, failure detection rules, request attributes, naming rules, maintenance windows and every other settings schema.
Without schema it lists the settings schemas; narrow the list with search (text matched against schema id and name, e.g. "alerting", "anomaly", "failure-detection").
With schema (e.g. builtin:alerting.profile) it prints the configured objects of that schema at scope (default environment; pass an entity id such as SERVICE-1234567890ABCDEF or HOST_GROUP-… for an entity-level override). Set effective: true to get the values actually in force at that scope, including inherited ones and defaults.
Values are printed as compact nested lists. Passwords, tokens, keys, credentials and anything else that looks like a secret are masked. The bridge cannot change settings.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: limit, scope, schema, search, +3 more.
service_backtraceA
Shows who calls a service (Dynatrace service backtrace): the upstream caller tree, level by level, up to the services where the requests enter (web entry points, background tasks, cron jobs). Each caller has the number of its requests involved, the resulting calls into the analysed service, how many of its requests start there, and its top calling requests with their SERVICE_METHOD ids.
Use it to find which upstream service, endpoint or job causes the load or the failures on a service or database. Pass service as an id or a name. The shared trace filters (response_time_min_ms, response_time_max_ms, http_code, failed, http_method, request, request_group_id, url_contains, request_kind, raw_filters) narrow the analysed requests. E.g. request backtraces one endpoint, failed: true only the failed calls.
For one SQL statement use statement_callers. Follow up with list_traces on a caller with request set to a calling request.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: service (required), limit, failed, request, +15 more.
service_flowA
Shows what a service calls (Dynatrace service flow): the downstream call tree of services, databases and external hosts as an indented tree. Each node has its contribution to the response time of the analysed service, the share of requests that make the call, calls per calling request, average time per call, call count and failed calls.
Use it to see which dependency a slow or failing service spends its time in. Pass service as an id or a name; max_depth limits how many call levels are followed. The shared trace filters (response_time_min_ms, response_time_max_ms, http_code, failed, http_method, request, request_group_id, url_contains, request_kind, raw_filters) narrow the analysed requests.
Follow up with analyze_response_time or service_flow on a downstream id, top_database_statements on a database node, or service_backtrace for the opposite direction.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: service (required), limit, failed, request, +14 more.
service_overviewA
Everything about one service in one call: type, technology, tags and properties; response time p50 / p90 / p99 / average, failure rate and throughput for the window, with a compact trend over time; the services it calls and the services that call it; the process groups, hosts, Kubernetes workloads and pods it runs on; and the Dynatrace problems that affected it in the window.
Pass service as an id (SERVICE-1234567890ABCDEF) or a name; an ambiguous name returns the candidates. Find services with list_services.
Then drill down with the same service and time window: list_service_requests (its endpoints), list_traces (individual requests), analyze_failures, analyze_response_time, service_flow (downstream), service_backtrace (upstream), and get_problem for a listed problem.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: service (required), time_to, time_from, environment, +2 more.
slow_statement_executionsA
Lists the slow executions of one SQL statement on a database service, slowest first: start time, duration, rows returned, fetches, and the traceId and callURI of the trace each execution belongs to.
Pass service (the database service, id or name), statement (id from top_database_statements, or a part of the SQL text) and optionally response_time_min_ms (default 100). The shared trace filters (response_time_min_ms, response_time_max_ms, http_code, failed, http_method, request, request_group_id, url_contains, request_kind, raw_filters) narrow the analysed requests.
Follow up with get_trace, passing the traceId and callURI of a row as trace_id and call_uri, to see the request that issued the statement and everything else it did.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: service (required), statement (required), limit, failed, +13 more.
statement_callersA
Finds what causes one SQL statement (Dynatrace backtrace of a database service filtered to the statement): the services that execute it, the exact requests, background tasks and cron jobs behind those services with their SERVICE_METHOD ids, and for each the number of requests and of resulting executions, followed by the upstream caller tree.
Pass service (the database service, id or name) and statement (id from top_database_statements, or a part of the SQL text). The shared trace filters (response_time_min_ms, response_time_max_ms, http_code, failed, http_method, request, request_group_id, url_contains, request_kind, raw_filters) narrow the analysed requests. E.g. response_time_min_ms backtraces only the slow executions.
Follow up with slow_statement_executions for single slow executions, or list_traces with service set to a caller id and request to a calling request.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: service (required), statement (required), limit, failed, +14 more.
thread_analysisA
Analyses the threads of a process group (Dynatrace continuous thread analysis): how many threads are in each state (running, locking, network I/O, disk I/O, optionally waiting), and the thread groups ranked by CPU time with their average thread count and state samples.
Use it to see whether a process is CPU-bound, blocked on locks or stuck in I/O, and which thread pool is responsible. state keeps only thread groups seen in that state and ranks by it (e.g. LOCK for lock contention). Follow up with method_hotspots on the same process group for the methods.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: process_group (required), limit, state, time_to, +4 more.
top_database_statementsA
Lists the SQL statements of a database ranked by cost: per statement the total time spent, the average, median, 95th percentile and slowest execution, the number of executions, and the statement id (SERVICE_METHOD-…). The tool for "which SQL is slow / expensive".
Pass service as the id or name of a database service. Dynatrace often has several database services with one name (one per calling process group): pass the name and their statements are combined by statement text in one table, with the service and statement id pairs each follow-up tool needs; pass an id for one of them alone. Combining costs two analysis requests whatever the number of services. Called without service, it lists the database services. sort ranks by total_time (default), avg, max, p95 or executions. Dynatrace returns at most its 100 statements with the largest total time, so the other sorts re-order only those and the output says so when statements were cut: a rare slow statement can be missing from "slowest". SQL text is cut to a readable length; pass full_sql: true for the whole text. The shared trace filters (response_time_min_ms, response_time_max_ms, http_code, failed, http_method, request, request_group_id, url_contains, request_kind, raw_filters) narrow the analysed requests.
Follow up with statement_callers (which services, requests and cron jobs issue a statement) and slow_statement_executions (its slow executions with the calling traces), passing the same service and the statement id as statement.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: sort, limit, failed, request, +15 more.
top_exceptionsA
Ranks the exception classes thrown in traced requests (Dynatrace multidimensional analysis "Exceptions overview"): per class the number of exceptions, Dynatrace's LOAD, AVERAGE and MAX aggregates of the exception count (read as: requests that had the exception, average and maximum per such request; that reading is not verified, so the columns keep Dynatrace's names), and, when no service is given, the services that throw it most with their ids.
Start here for "which exceptions occur most". Call it without service for the whole environment, or with service (id or name) for one service. The shared trace filters (response_time_min_ms, response_time_max_ms, http_code, failed, http_method, request, request_group_id, url_contains, request_kind, raw_filters) narrow the analysed requests.
Follow up with analyze_failures on a service that throws the exception (not every exception fails a request), or list_traces with raw_filters: [{ type: "EXCEPTION", values: ["<class>"] }] for traces containing it.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: limit, failed, request, service, +14 more.
trace_statisticsA
Multidimensional analysis over traces: aggregates one metric over all matching requests, split by one dimension, across all services or for one. The tool for "which endpoints are the slowest / cost the most time / burn the most CPU / fail the most".
Recipes (the metric defaults to RESPONSE_TIME and the dimension to the request name {Request:Name}; add request_kind: "web" to rank HTTP endpoints only, because without it SQL statements dominate an environment-wide ranking; add service for one service):
slowest endpoints:
aggregation: "P95"(or"AVERAGE", the default for time metrics) withmin_calls: 20, so that requests seen once or twice do not win;most time-consuming endpoints:
aggregation: "SUM";most CPU:
metric: "CPU_TIME",aggregation: "SUM";most errors:
metric: "FAILED_REQUEST_COUNT"(orHTTP_5XX_ERROR_COUNT), a count metric, ranked by itsCOUNTby default;by something else:
dimension: "{Relative-URL}","{HTTP-Status}","{Exception:Class}","{Service:Name}", or a request attribute as"{RequestAttribute:<name>}".
list_definitions: true lists the metrics, dimensions and request attributes this environment has. aggregation picks the column the rows are ranked by; the header names it. The table shows every aggregate Dynatrace returns. For a time metric these are requests (the number of requests), avg, median, p90, p95, the chosen percentile, max, min and sum. For a count metric (Dynatrace returns a COUNT for it) they are printed under Dynatrace's own names, COUNT, COUNT_PER_MINUTE, LOAD, AVERAGE, MIN, MAX, with a line saying what is known about them. timeseries: true adds the top values over time.
Each row prints the request id and, without service, the service it belongs to. Dynatrace returns at most its top 100 values, those with the largest total (sum, or COUNT for a count metric), and leaves out values with too few sampled requests. Ranking by anything else (avg, p95, max, …) re-sorts only those 100, so a rarely called slow request outside them is missing; the output says when that happened.
This tool runs through the Dynatrace Bridge browser extension in the user's logged-in browser. If it fails, report the error to the user; do not try to open browser tabs or use browser automation instead.
Inputs: limit, failed, metric, request, +23 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 39 tools
Most tools target clearly distinct resources and actions (entity search vs detail, list vs aggregate, profiling views), and descriptions cross-reference each other well. A few boundaries blur—list_events overlaps with pod_events for Kubernetes events, and generic get_entity competes with specialized get_host/get_process/get_problem—but the detailed descriptions mitigate most confusion.
The set mixes verb_noun names (get_host, list_pods, query_metrics, analyze_failures, read_settings) with bare domain noun phrases (pod_resources, trace_statistics, method_hotspots, service_flow, thread_analysis). It is consistent within categories (list_*, get_*, analyze_*) but does not follow one predictable pattern throughout.
With 39 tools, the surface is well above the typical 3–15 range and heavy for an agent to navigate. While Dynatrace is a broad platform, some tools (e.g., list_events vs pod_events, list_traces vs trace_statistics) could be consolidated or scoped more tightly.
Read-only coverage is broad: entities, metrics, problems, events, traces, service analysis, Kubernetes workloads/pods, processes, dashboards, and settings. Gaps are minor (e.g., no RUM/user-session or log-query tools) and write operations are absent by design, so core observability workflows are complete.
Maintenance
Related MCP Connectors
Lets AI agents analyze API metrics, request logs, and traces, and manage apps and alerts.
Let AI agents use any website you're logged in to. Sessions stay encrypted on your machine.
Query your app's logs, metrics and incidents from your AI assistant.
Connect AI assistants to your approved computer for files, commands, browser and desktop tasks.
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables AI assistants to interact with self-hosted Dynatrace Managed environments to retrieve observability data, security insights, and performance metrics. It allows users to query problems, logs, events, and SLOs through natural language interfaces in both local and remote modes.18790 npm34Apache 2.0
- AlicenseBqualityCmaintenanceEnables LLM agents to query Dynatrace SaaS for observability data (logs, metrics, traces, entities, problems, vulnerabilities) and manage configurations (dashboards, notebooks, SLOs, synthetic monitors, settings).100MIT
- AlicenseNot gradedqualityDmaintenanceA powerful Model Context Protocol (MCP) server that provides AI assistants with comprehensive access to Dynatrace's observability platform. Features dual authentication architecture, Davis CoPilot AI integration, and 24 specialized tools for monitoring, automation, and operational intelligence.23 npm5MIT
- AlicenseAqualityBmaintenanceLets AI assistants safely explore a Matrix42 instance by discovering web services and the data model, running validated ASQL queries, searching the service desk, and previewing ticket actions — read-only by default and without exposing credentials.544 npmMIT