Skip to main content
Glama
dynatrace-bridge-mcp

dynatrace-bridge-mcp

by yunusemregul

Dynatrace Bridge MCP

npm CI node license

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.

The result of the list_services tool rendered as a table: six services with id, type, technology, average and p90 response time, failure rate, request count and throughput, sorted by average response time, followed by a hint to call service_overview next. The data is synthetic.

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.

Architecture: the AI client (Claude Code, Cursor, Codex, …) talks to the MCP server over stdio or HTTP on localhost:47832. The server talks over a WebSocket on localhost:47831 to the Dynatrace Bridge browser extension in your logged-in Dynatrace tab. All three run on your machine. The extension sends GET requests to /e/{env}/rest/* on Dynatrace Managed, which answers with your existing login.

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-extension

This 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.

Turn on Developer mode Click Load unpacked Dynatrace Bridge installed

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.

  1. Check node --version is 18 or newer, then register the server with the client you're running in (commands; use the cmd /c form on Windows).

  2. Run npx -y dynatrace-bridge-mcp@latest install-extension. It prints the folder path (--no-open skips opening the browser, --no-copy leaves the clipboard alone, --browser <name> picks a browser).

  3. Ask the user to turn on Developer mode, click Load unpacked and paste that path. Wait for them to confirm.

  4. 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.

  5. Ask the user to restart the client or reconnect MCP servers (/mcp in Claude Code) so the tools load.

  6. Verify with curl -s http://localhost:47832/health. You want "connected":true and at least one name in "environments". No answer means the client hasn't started the server yet. Finish with dynatrace_bridge_status (pass check_session: true to test the login as well).

What to ask

Ask

Tools the AI reaches for

"Which endpoints are the slowest?"

trace_statistics with request_kind: "web", ranked by P95 or AVERAGE

"Which endpoints use the most CPU / fail the most?"

trace_statistics with metric: "CPU_TIME" or "FAILED_REQUEST_COUNT"

"Why is the checkout service failing?"

list_services, service_overview, analyze_failures, then list_traces and get_trace

"Where does this service spend its time?"

analyze_response_time, service_flow, method_hotspots

"Which SQL is slow, and who runs it?"

top_database_statements, statement_callers, slow_statement_executions

"Which cron jobs take the longest?"

cron_job_statistics

"Why does this pod restart? Was it OOM-killed?"

list_workloads, pod_resources, pod_events, process_runtime

"What happened in problem P-12345?"

get_problem, then the service tools for the affected service and window

"Show me slow traces of GET /api/cart"

list_traces with request or url_contains and response_time_min_ms, then get_trace and get_trace_details

Tools

39 tools, listed in the order the server presents them.

Start here: status, entities, metrics

Tool

What it does

dynatrace_bridge_status

Server and extension versions, connected browsers, configured environments; optionally checks each login.

find_entities

Finds entities of any type by name or entity selector and returns their ids.

get_entity

One entity in full: properties, tags, management zones, relationships.

find_metrics

Searches the metric catalogue for ids, units and dimensions.

query_metrics

Runs any metric selector and summarises each series (min, avg, max, trend, values over time).

Services, events, problems

Tool

What it does

list_services

Services with response time, failure rate and throughput; sortable.

service_overview

One service: percentiles, failures, throughput, callers and callees, hosts and pods, problems.

list_events

Deployments, restarts, Kubernetes and anomaly events, identical ones collapsed.

list_problems

Problems active in the window, filterable by status, impact, severity and entity.

get_problem

One problem as a compact overview: evidence by entity, root cause findings, impact, trigger event, affected requests, dependency path; detail gives one section in full.

Kubernetes, hosts, processes

Tool

What it does

list_workloads

Workloads with running and desired pods, CPU and memory against requests and limits.

list_pods

Pods of a workload with phase, node, restarts, requests and limits, containers.

pod_resources

CPU, throttling, memory, OOM kills and restarts per pod and container over time.

pod_events

Kubernetes events of a workload's pods: probe failures, kills, scheduling, deploys.

process_runtime

JVM heap and GC or Node.js heap and event loop metrics of the processes in a pod.

get_host

One host: hardware, availability, CPU, memory, disks, processes, events.

get_process

One process or process group: technology, where it runs, services, callers and callees.

Traces

Tool

What it does

list_service_requests

Endpoints of a service, SQL statements of a database service, or target hosts of an "unmonitored hosts" service, with metrics.

list_traces

Single traces of a service or the whole environment, filtered by response time, HTTP code, failure, method, request or URL.

trace_statistics

Any trace metric split by any dimension (multidimensional analysis), with the same filters.

get_trace

One trace as a span tree with timings, SQL and downstream calls.

get_trace_details

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

analyze_failures

Why requests of a service fail: reasons, exceptions, failed downstream calls.

analyze_response_time

Where the response time goes (code, downstream, database) and how it is distributed.

service_flow

What a service calls, as a tree with each dependency's contribution.

service_backtrace

Who calls a service, up to the entry requests and jobs.

top_exceptions

Exception classes by count, across services or for one.

cron_job_statistics

Cron jobs by total time, average, longest run, executions and failures.

top_database_statements

SQL statements of a database service by total time, average, max or executions; database services that share a name are combined.

statement_callers

Which services, requests and jobs execute one SQL statement.

slow_statement_executions

Slow executions of one statement with the traces they belong to.

Profiling

Tool

What it does

cpu_by_process_group

Process groups by CPU time.

method_hotspots

Hot methods of a service or process group from code-level samples.

thread_analysis

Thread groups of a process group by state and CPU.

memory_allocation_hotspots

Where a Java process group allocates memory.

list_process_crashes

Process crashes in the window.

Dashboards and settings

Tool

What it does

list_dashboards

Dashboards visible to you.

get_dashboard

Tiles of a dashboard and the metric selectors behind its charts.

read_settings

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_dashboards and read_settings have 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 (web or database).

  • 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 WS_PORT, set the same port behind the ⚙ in the popup.

"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 /e/<environment id>/, which is how Dynatrace Managed addresses an environment. If it does and you are logged in, reload the page and reopen the popup.

"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 install-extension, reload the extension and add the environment again. For a fork or a build with another key, list its origin in DT_BRIDGE_EXTENSION_ORIGINS.

"Port 47831 (or 47832) is in use by another program"

Free the port or set WS_PORT / MCP_PORT (see below).

"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

MCP_PORT

47832

HTTP port for MCP clients (/mcp, /sse, /health)

WS_PORT

47831

WebSocket port for the extension (also change it behind the ⚙ in the popup)

HOST

127.0.0.1

Bind address of both ports

EXTENSION_WAIT_MS

10000

How long a tool call waits for the extension to connect before it fails

DT_BRIDGE_UPDATE_CHECK

on

0 or false turns off the daily version check against the npm registry

DT_BRIDGE_UPDATE_URL

https://registry.npmjs.org/dynatrace-bridge-mcp/latest

Where the version check looks, for a registry mirror

DT_BRIDGE_ALLOWED_ORIGINS

empty

Web origins that may call the HTTP port, comma- or space-separated. Only for a browser-based MCP client

DT_BRIDGE_EXTENSION_ORIGINS

empty

Extra extension origins that may connect to the WebSocket, e.g. chrome-extension://<id> of a fork

DT_BRIDGE_SERVER_VERSION

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 GET is 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 contain apiTokens, credentials, tokens or 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 loopback Host header, and refuses any request that carries a browser Origin unless 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 verify

npm 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

MIT

Available Tools

39 tools
analyze_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, then get_problem with the P- id.

  • A slow or failing service: list_services (sort: "response_time" or "failure_rate") to find it, service_overview, then analyze_response_time or analyze_failures, then list_traces and get_trace for single requests.

  • Across all services, trace_statistics with request_kind: "web" and: slowest endpoints aggregation: "P95" (or "AVERAGE") plus min_calls: 20; most time-consuming endpoints aggregation: "SUM"; most CPU metric: "CPU_TIME", aggregation: "SUM"; most errors metric: "FAILED_REQUEST_COUNT" (a count metric, ranked by its COUNT).

  • 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, then pod_resources and pod_events. CPU or memory of a process: cpu_by_process_group, method_hotspots, process_runtime.

  • Anything else: find_entities for ids, find_metrics and query_metrics for 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):names

  • builtin:containers.memory.residentSetBytes:splitBy("dt.entity.container_group_instance"):max:names Several selectors can be given comma-separated. Append :names so entity names are shown next to their ids. Find metric ids with find_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) with min_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" (or HTTP_5XX_ERROR_COUNT), a count metric, ranked by its COUNT by 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

    A4.1/5.0

    Scored across 39 tools

    Disambiguation4/5

    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.

    Naming Consistency3/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityNo data
    ResponsivenessSyncing

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Enables 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.
      18
      790 npm
      34
      Apache 2.0
    • A
      license
      B
      quality
      C
      maintenance
      Enables LLM agents to query Dynatrace SaaS for observability data (logs, metrics, traces, entities, problems, vulnerabilities) and manage configurations (dashboards, notebooks, SLOs, synthetic monitors, settings).
      100
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A 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 npm
      5
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Lets 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.
      5
      44 npm
      MIT