Dt Obs Frontends logo

Dt Obs Frontends

Organization
Dynatrace
dt-obs-frontends

Real User Monitoring (RUM) on Dynatrace — web and mobile frontends. Core Web Vitals, user sessions, page performance, mobile crashes, frontend errors, and frontend-backend linking. Query via `user.events`, `user.sessions`, and `dt.frontend.*` metrics. Does NOT cover synthetic monitoring (HTTP/browser/network checks) — that's a separate domain.

Overview

PublisherDynatrace
Repositorydynatrace-for-ai
Skill namedt-obs-frontends
Stars
156
Forks
30
Bundled files
12
LicenseApache-2.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 12 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by Dynatrace on GitHub. Read the source before you install it.

Installation

Install the Dt Obs Frontends AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/Dynatrace/dynatrace-for-ai.git /tmp/dynatrace-for-ai
mkdir -p .claude/skills
cp -r /tmp/dynatrace-for-ai/skills/dt-obs-frontends .claude/skills/dt-obs-frontends
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Dt Obs Frontends in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Dt Obs Frontends on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Dt Obs Frontends is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Frontend Observability (RUM)

Monitor web and mobile frontends using Real User Monitoring with DQL. Targets RUM on the latest Dynatrace — do not use RUM Classic data.

Concepts and data model: https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/concepts

Data Model

Three data sources, each for a different question:

SourceUse forGranularity
timeseries dt.frontend.*Trends, dashboards, alertingAggregated metric
fetch user.eventsRoot cause, individual page views / requests / clicks / errorsPer-event
fetch user.sessionsBounce rate, session duration, session-level aggregatesPer-session

Rule of thumb: start with metrics for the shape of the problem, drill into events for the why. Use sessions when the question is about user journeys, not individual interactions.

Full event model: https://docs.dynatrace.com/docs/semantic-dictionary/model/rum/user-events

DQL language reference (functions, syntax, operators): https://docs.dynatrace.com/docs/platform/grail/dynatrace-query-language

Key dt.frontend.* metrics (all support dimensions: frontend.name, device.type, geo.country.iso_code, browser.name, os.name, dt.rum.user_type, dt.smartscape.frontend):

  • dt.frontend.web.page.largest_contentful_paint / dt.frontend.web.page.interaction_to_next_paint / dt.frontend.web.page.cumulative_layout_shift / dt.frontend.web.page.first_input_delay — Core Web Vitals
  • dt.frontend.web.navigation.time_to_first_byte / dt.frontend.web.navigation.dom_interactive / dt.frontend.web.navigation.load_event_end — Navigation timing
  • dt.frontend.error.count — Error counts
  • dt.frontend.request.count / dt.frontend.request.duration — Request volume and latency
  • dt.frontend.user_action.count / dt.frontend.user_action.duration — User action volume and duration
  • dt.frontend.session.active.estimated_count / dt.frontend.user.active.estimated_count — Active sessions and users (cardinality metrics; use countDistinct() aggregation)

Common Filters

All sources (user.events + user.sessions):

  • frontend.name — frontend identifier (preferred for all filtering); array on user.sessions (session can span multiple frontends). dt.smartscape.frontend is the Smartscape entity reference — use it to access entity attributes such as tags or linked services, not for name-based filtering. Avoid querying Smartscape to resolve a name to an entity ID and then joining with user.events — always filter on frontend.name directly.
  • dt.rum.user_typereal_user, synthetic, robot
  • dt.rum.application.typeweb or mobile
  • dt.rum.session.id, dt.rum.instance.id
  • os.name, geo.country.iso_code, client.isp
  • client.ip — client IP address (sensitive field — hidden by default; see Field Permissions below)

user.events — web only:

  • browser.name, browser.version, device.type

user.events — mobile only:

  • device.model.identifier, device.manufacturer, app.short_version

Common characteristic filters (scope user.events to a specific event type — use as | filter characteristics.has_X):

  • characteristics.has_page_summary — page loads (web)
  • characteristics.has_view_summary — views (SPA + mobile screens)
  • characteristics.has_navigation — navigation events
  • characteristics.has_user_action — user actions
  • characteristics.has_error — all errors

Full characteristics reference: references/characteristics.md

Field Permissions

Some fields are sensitive and belong to the builtin-sensitive-user-events-and-sessions fieldset. They are hidden by default on both user.events and user.sessions — users without access see null, and queries that filter or group by these fields silently return no results.

Sensitive fields used in this skill:

  • client.ip — client IP address
  • user.identifier — real user identity

Grant access with the following policy statement:

ALLOW storage:fieldsets:read WHERE storage:fieldset-name="builtin-sensitive-user-events-and-sessions"

Reference: Field permissions

Drill-Down Pattern

Most investigations follow this layered approach regardless of the specific problem domain (errors, performance, background activity, etc.):

1. Identify the frontend

Start by grouping by: {frontend.name} to find which application is affected. Filter by dt.rum.application.type (web or mobile) if you need to split web from mobile analysis upfront.

2. Find the affected page or view

Both fields are available on all events (not scoped to a specific characteristic):

  • page.name — the page URL normalised to a Dynatrace entity name; web only
  • view.name — the SPA route or mobile screen name; available on web and mobile

Both can be present on the same event. For web SPAs, page.name reflects the top-level document while view.name reflects the current route — grouping by view.name gives finer granularity. For mobile, use view.name only.

Additional narrowing dimensions

DimensionFieldPlatformWhen to use
Specific request / endpointurl.domain, url.pathweb + mobilePerformance or error pattern on a specific API call
Individual user sessiondt.rum.session.idweb + mobileReproduce a specific user's journey; connects to session replay
Device form factordevice.typeweb onlyDesktop vs mobile browser vs tablet pattern
Browser compatibilitybrowser.name, browser.versionweb onlyIssue only on certain browsers
App versionapp.short_versionmobile onlyRegression introduced in a specific app release
Geographygeo.country.iso_codeweb + mobileRegional infrastructure or CDN issue
Synthetic vs real trafficdt.rum.user_typeweb + mobileExclude synthetic monitors before user-facing analysis

Workflows

Each workflow maps to one or more references. Load the reference when you start the workflow, not upfront.

WorkflowReference
Event characteristics — types, filters, event_type derivationreferences/characteristics.md
Web Vitals (LCP, FCP, FID, INP, CLS)references/web-vitals.md
Session, bounce, engagement analysisreferences/user-sessions.md
User actions — interaction lifecycle, completion reasons, timeoutsreferences/user-actions.md
Errors, exceptions, failed requestsreferences/error-tracking.md
Frontend-backend linking — mechanisms, trace coverage, frontend.linkreferences/frontend-backend-linking.md
CSP violations — security policy enforcement and blocked resourcesreferences/csp-violations.md
Mobile app starts, crashes, ANR, native signalsreferences/mobile-monitoring.md
Request latency, long tasks, JS profiling, geo performancereferences/web-performance-analysis.md
Visibility changes — tab switching, background time, engagement qualityreferences/visibility-changes.md
Slow page load — backend vs render vs network vs JS triagereferences/slow-page-load-playbook.md
Diagnosing zero results, anomalies, ambiguous datareferences/troubleshooting.md

Performance Thresholds (quick reference)

  • LCP: Good < 2.5 s | Poor > 4.0 s
  • INP: Good < 200 ms | Poor > 500 ms
  • CLS: Good < 0.1 | Poor > 0.25
  • FCP: Good < 1.8 s | Poor > 3.0 s
  • TTFB: Good < 800 ms | Poor > 1800 ms
  • Mobile cold start: Good < 3 s | Poor > 5 s
  • Mobile warm start: Good < 1.5 s | Poor > 2 s
  • Mobile hot start: Good < 500 ms | Poor > 1 s
  • Long tasks: > 50 ms problematic, > 250 ms severe

Web vitals thresholds (LCP, INP, CLS, FCP, TTFB): https://web.dev/articles/vitals

When to Use

Use this skill for real-user web and mobile frontend telemetry — Core Web Vitals, sessions, clicks, errors, crashes, request latency from the browser/app, and frontend-backend linking.

Use a different skill for:

  • Synthetic monitors / availability checks → dt-obs-synthetic
  • Backend services, traces, spans → dt-obs-services, dt-obs-tracing
  • Infrastructure, hosts → dt-obs-hosts
  • Logs → dt-obs-logs
  • Problems and incidents → dt-obs-problems

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Dt Obs Frontends AI skill do?

Real User Monitoring (RUM) on Dynatrace — web and mobile frontends. Core Web Vitals, user sessions, page performance, mobile crashes, frontend errors, and frontend-backend linking. Query via `user.events`, `user.sessions`, and `dt.frontend.*` metrics. Does NOT cover synthetic monitoring (HTTP/browser/network checks) — that's a separate domain.

Why use Dt Obs Frontends on TypingMind?

Because you install it once and use it with any model. Dt Obs Frontends is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Dt Obs Frontends in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/Dynatrace/dynatrace-for-ai/tree/main/skills/dt-obs-frontends. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Dt Obs Frontends?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Dt Obs Frontends?

As many as you like. As long as a model supports skills, you can use Dt Obs Frontends with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Dt Obs Frontends AI skill free?

Yes. It is published on GitHub by Dynatrace under the Apache-2.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇