dt-app-notebooks
dynatrace/dynatrace-for-ai
Create, modify, and analyze Dynatrace notebooks with DQL queries and visualizations.
What is dt-app-notebooks?
This skill enables you to work with Dynatrace notebooks—JSON documents containing markdown and DQL query sections. Use it when you need to create new notebooks, update existing ones, or analyze notebook structure and queries.
- Create notebooks with markdown narrative and DQL query sections
- Modify existing notebooks by reading, editing, and deploying JSON changes
- Add and configure DQL queries with visualization settings (line charts, bar charts, tables, etc.)
- Set default timeframes and query parameters like max results and sampling ratios
- Validate notebook JSON and deploy changes using dtctl apply
- Analyze notebook structure to extract queries and understand notebook purpose
How to install dt-app-notebooks
npx skills add https://github.com/dynatrace/dynatrace-for-ai --skill dt-app-notebooks- Dynatrace environment with Document Store access
- dtctl CLI installed and configured
- Basic understanding of DQL (Dynatrace Query Language)
How to use dt-app-notebooks
- 1.Load domain skills before generating any DQL queries to ensure accuracy
- 2.Fetch the current notebook state with `dtctl get notebook <id> -o json` if updating
- 3.Create or modify the notebook JSON, ensuring sections have proper type (markdown or dql)
- 4.Validate all DQL queries in sections before adding them to the notebook
- 5.Set `autoSelectVisualization: true` unless a specific chart type is required
- 6.Deploy changes using `dtctl apply` and fix any validation errors reported
- 7.Verify the notebook renders correctly in the Dynatrace UI
Use cases
- Build a monitoring dashboard notebook with multiple DQL queries analyzing logs and metrics
- Update an existing notebook to add a new query section without overwriting user UI edits
- Create a time-series analysis notebook with line charts showing system performance over time
- Generate a categorical analysis notebook with pie charts summarizing data by field
- Analyze a notebook's DQL queries to understand what data it's collecting
- Dynatrace platform users building monitoring dashboards
- DevOps engineers creating analysis notebooks
- Data analysts querying Dynatrace logs and metrics
- Teams automating notebook creation and updates
dt-app-notebooks FAQ
When creating, build the JSON from scratch. When updating, always fetch the current state first with `dtctl get notebook <id> -o json`, modify that file, then deploy—never reconstruct from scratch, as this overwrites UI edits users made since last deployment.
Yes. Set a default timeframe in `content.defaultTimeframe`, and override it per section via `section.state.input.timeframe`. You can also hardcode time filters directly in DQL.
Notebooks support time-series charts (line, area, bar, band), categorical charts (bar, pie, donut), single values, tables, histograms, maps (choropleth, dot, bubble, connection), heatmaps, and scatterplots. Choose based on your data shape and query output.
Always load domain skills first—do not invent DQL. Domain skills provide validated query patterns for your Dynatrace environment.
Fix all reported errors in the notebook JSON and re-apply. Common issues include missing required fields in visualization settings, invalid section types, or malformed DQL.
Full instructions (SKILL.md)
Source of truth, from dynatrace/dynatrace-for-ai.
name: dt-app-notebooks description: Work with Dynatrace notebooks - create, modify, query, and analyze notebook JSON including sections, DQL queries, and visualizations. license: Apache-2.0
Dynatrace Notebook Skill
Overview
Dynatrace notebooks are JSON documents stored in the Document Store containing an ordered array of sections — markdown blocks for narrative and dql blocks for DQL queries with visualizations. Sections render top-to-bottom in array order.
When to use: Creating, modifying, querying, or analyzing notebooks.
Notebook JSON Structure
{
"name": "My Notebook",
"type": "notebook",
"content": {
"version": "7",
"defaultTimeframe": { "from": "now()-2h", "to": "now()" },
"sections": [
{ "id": "1", "type": "markdown", "markdown": "# Title" },
{
"id": "2", "type": "dql", "title": "Query Section", "showInput": true,
"state": {
"input": { "value": "fetch logs | summarize count()" },
"visualization": "table",
"visualizationSettings": { "autoSelectVisualization": true, "chartSettings": {} },
"querySettings": {
"maxResultRecords": 1000, "defaultScanLimitGbytes": 500,
"maxResultMegaBytes": 1, "defaultSamplingRatio": 10, "enableSampling": false
}
}
}
]
}
}
- Sections render in array order.
- Section types:
markdown,dql. (functionexists but is rare.) - Use string-int IDs (
"1","2", …); UUIDs are also accepted. content.defaultTimeframesets the default timeframe; each section can override viasection.state.input.timeframe. Hardcoded time filters in DQL are allowed.
Optional content properties: defaultSegments.
Reading & Analyzing
Fetch full content with dtctl get notebook <id> -o json (describe returns metadata only), then inspect the JSON to discover its available properties. Carefully read references/analyzing.md before analyzing.
Create/Update Workflow (Mandatory Order)
Carefully follow the workflow described in references/create-update.md.
Key rules:
- Load domain skills BEFORE generating queries — do not invent DQL.
- Validate ALL section queries before adding to the notebook.
- Set
namebefore deploying. - Prefer
autoSelectVisualization: trueinvisualizationSettingsunless the user requested a specific visualization type — whenfalse,state.visualizationmust be set explicitly. - Updating — ALWAYS read the current state first:
dtctl get notebook <id> -o json, save it asnotebook.json, modify that file, then deploy it. Never reconstruct JSON from scratch or inject anidmanually — both silently overwrite UI edits the user made since last deployment. - Deploy with
dtctl apply— validation runs automatically. If it fails, fix all reported errors before re-applying.
Visualization Types
Notebooks support a subset of Dynatrace visualizations:
- Time-series (require
timeseries/makeTimeseries):lineChart,areaChart,barChart,bandChart - Categorical (
summarize ... by:{field}):categoricalBarChart,pieChart,donutChart - Single value / gauge / meter:
singleValue,meterBar,gauge - Tabular (any data shape):
table,raw,recordView - Distribution/status:
histogram,honeycomb - Geographic maps:
choropleth,dotMap,connectionMap,bubbleMap - Matrix/correlation:
heatmap,scatterplot
Required field types per visualization: references/sections.md.
References
| File | When to Load |
|---|---|
| create-update.md | Creating/updating notebooks |
| sections.md | Section types, visualization field requirements, settings |
| analyzing.md | Reading notebooks, extracting queries, purpose identification |
Related skills
More from dynatrace/dynatrace-for-ai and the wider catalog.

dt-dql-essentials
Write, optimize, and fix DQL queries with syntax guidance, patterns, and cost-reduction techniques.

dt-js-runtime
Dynatrace server-side JavaScript runtime for executing functions with Web APIs, Node.js modules, and SDK access.

dt-migration
Migrate Dynatrace classic and Gen2 entity-based DQL queries to Smartscape equivalents.

dt-obs-aws
Monitor and analyze AWS infrastructure—EC2, RDS, Lambda, ECS/EKS, VPC, load balancers, storage, and costs—using Dynatrace Smartscape and DQL.

dt-obs-azure
Monitor and audit Azure infrastructure, resources, and security posture in Dynatrace.

dt-obs-frontends
Real User Monitoring (RUM) on Dynatrace — monitor web and mobile frontend performance, errors, and user sessions.