PluginBench
Skill
Review
Audit score 70

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
Prerequisites
  • Dynatrace environment with Document Store access
  • dtctl CLI installed and configured
  • Basic understanding of DQL (Dynatrace Query Language)
Claude Code
Cursor
Windsurf
Cline

How to use dt-app-notebooks

  1. 1.Load domain skills before generating any DQL queries to ensure accuracy
  2. 2.Fetch the current notebook state with `dtctl get notebook <id> -o json` if updating
  3. 3.Create or modify the notebook JSON, ensuring sections have proper type (markdown or dql)
  4. 4.Validate all DQL queries in sections before adding them to the notebook
  5. 5.Set `autoSelectVisualization: true` unless a specific chart type is required
  6. 6.Deploy changes using `dtctl apply` and fix any validation errors reported
  7. 7.Verify the notebook renders correctly in the Dynatrace UI

Use cases

Good for
  • 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
Who it's for
  • 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

What's the difference between creating a new notebook and updating an existing one?

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.

Can I set different timeframes for individual sections?

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.

What visualization types are supported?

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.

Do I need to invent DQL queries or load domain skills first?

Always load domain skills first—do not invent DQL. Domain skills provide validated query patterns for your Dynatrace environment.

What happens if dtctl apply validation fails?

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. (function exists but is rare.)
  • Use string-int IDs ("1", "2", …); UUIDs are also accepted.
  • content.defaultTimeframe sets the default timeframe; each section can override via section.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 name before deploying.
  • Prefer autoSelectVisualization: true in visualizationSettings unless the user requested a specific visualization type — when false, state.visualization must be set explicitly.
  • Updating — ALWAYS read the current state first: dtctl get notebook <id> -o json, save it as notebook.json, modify that file, then deploy it. Never reconstruct JSON from scratch or inject an id manually — 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

FileWhen to Load
create-update.mdCreating/updating notebooks
sections.mdSection types, visualization field requirements, settings
analyzing.mdReading notebooks, extracting queries, purpose identification