Configure DQL tiles to track release-related issues with deep links

Latest Dynatrace
Tutorial
5-min read
Published Jun 30, 2026

To navigate directly from a release to its issues in an external tracker, you can configure deep links to your issue-tracking system into your dashboard using DQL (Dynatrace Query Language). For example, you can add dedicated issue-tracking tiles to any existing dashboard, such as the Release monitoring dashboard.

To configure the links, you don't need to store credentials in Dynatrace. Each dashboard tile builds a deep link URL to the issue tracker's native search UI, pre-filtered with the selected release context.

While you can establish dynamic links for any issue-tracking system you have access to and that offers a URL, this guide provides examples for the following systems:

Jira Cloud and Jira on-premises
GitHub
GitLab
ServiceNow

Who is this for?

This tutorial is for engineers and platform teams who:

Use release monitoring and want to navigate directly from a release to its open issues in an external tracker.
Want to reduce context switching between the dashboard and Jira, GitHub, GitLab, or ServiceNow.
Have version metadata configured on their processes and are prepared to adjust existing tag values if needed.

What will you learn?

In this guide, you'll add a DQL tile that queries live process release metadata and renders deep link URLs to your issue tracker as a clickable table.

The tile's DQL configuration has three parts:

Variable queries: One DQL query per variable (Stage, Product, Version) that populates the dropdown values from live process data.
Base DQL filter pattern: The tile's main query that filters processes by the selected variables and deduplicates by product × version.
URL pattern: A tool-specific DQL query that assembles the deep link URL using concat().

Before you begin

Prerequisites

Version metadata (DT_RELEASE_STAGE, DT_RELEASE_PRODUCT, DT_RELEASE_VERSION) is set on your processes. To set up version metadata, see Version detection methods.
Your DT_RELEASE_PRODUCT and DT_RELEASE_VERSION tag values use slug-style formatting (for example, cart-service, 1.2.1). Values with spaces, quotes, or special characters will produce broken URLs.

Prior knowledge

Basic familiarity with Dashboards, such as creating tiles and configuring dashboard variables.
Basic DQL syntax. The guide provides the full queries, but knowing what a pipe operator (|) and a field expression are helps you adapt them.

Create deep link URLs in a dashboard

1. Create a new tile

Go to Dashboards.
Select at the top left of your dashboard to create a new tile.
Select DQL.

2. Define scope variables

Define cascading Stage, Product, and Version variables to scope the tile. These are standard query-type variables backed by smartscapeNodes. See Add a variable to a dashboard for further information. Alternatively, you can hard-code your stage, product, and version information as a list or free text.
For each variable, use the following DQL query as its data source. Each query reads live process data and returns a deduplicated list of values.

Reference variables in the tile query with in(field, array($Variable)).

smartscapeNodes "PROCESS"
| filter isNotNull(tags[DT_RELEASE_STAGE]) and tags[DT_RELEASE_STAGE] != ""
| fieldsAdd stage = tags[DT_RELEASE_STAGE]
| dedup stage
| fields stage
| sort stage asc

Depends on Stage.

smartscapeNodes "PROCESS"
| filter in(tags[DT_RELEASE_STAGE], array($Stage))
| filter isNotNull(tags[DT_RELEASE_PRODUCT]) and tags[DT_RELEASE_PRODUCT] != ""
| filter isNotNull(tags[DT_RELEASE_VERSION]) and tags[DT_RELEASE_VERSION] != ""
| fieldsAdd product = tags[DT_RELEASE_PRODUCT]
| dedup product
| fields product
| sort product asc

Depends on Stage and Product.

smartscapeNodes "PROCESS"
| filter in(tags[DT_RELEASE_STAGE], array($Stage))
| filter isNotNull(tags[DT_RELEASE_PRODUCT]) and tags[DT_RELEASE_PRODUCT] != ""
| filter isNotNull(tags[DT_RELEASE_VERSION]) and tags[DT_RELEASE_VERSION] != ""
| fieldsAdd product = tags[DT_RELEASE_PRODUCT]
| dedup product
| fields product
| sort product asc

Select multiple selection for all three variables so you can filter by multiple values at once. In data tiles, the DQL deduplicates to one row per product × version, so each row always produces a single URL. In Markdown tiles, avoid multi-select for $Product and $Version when those values are embedded directly in URLs. When no value is selected, array($Variable) returns an empty array, and the tile shows no rows. This is the expected behavior.

3. Add the base DQL filter pattern

Select the tile.
Choose Edit from the tile menu.
In the Data tab, open the DQL expand.

Add the base DQL filter pattern shown below. This base DQL filter ensures the dashboard tile considers the selected dashboard variables for stage, product, and version.

smartscapeNodes "PROCESS"
| filter isNotNull(tags[DT_RELEASE_VERSION]) and tags[DT_RELEASE_VERSION] != ""
| filter in(tags[DT_RELEASE_STAGE],   array($Stage))
| filter in(tags[DT_RELEASE_PRODUCT], array($Product))
| filter in(tags[DT_RELEASE_VERSION], array($Version))
| dedup tags[DT_RELEASE_PRODUCT], tags[DT_RELEASE_VERSION]
| fields product = tags[DT_RELEASE_PRODUCT], version = tags[DT_RELEASE_VERSION]
// continue with tool-specific fieldsAdd in the next step

4. Add the URL pattern

Select the pattern for your issue-tracking system from the tabs below.

Append it to the base DQL filter pattern.

Target URL

https://{your-subdomain}.atlassian.net for Jira Cloud
https://jira.{your-domain}.com for Jira on-premises

Jira accepts a ?jql= parameter with URL-encoded JQL. The following JQL fields are common for release filtering:

JQL field	Meaning
`affectedVersion`	Version the issue was reported against
`fixVersion`	Version the issue is scheduled to be fixed in
`labels`	Free-text labels (can carry product/version)
`component`	Component name
`issuetype`	`Bug`, `Task`, `Story`, etc.
`status`	`Open`, `In Progress`, `Done`, `Resolved`, `Closed`
`assignee`	`currentuser()` for the logged-in user

| fieldsAdd
    target_url      = "https://{your-subdomain}.atlassian.net",
    project         = "{your-project-key}",
    assignee        = "currentuser()",
    type            = "Bug",
    affectedversion = version

| fieldsAdd jql = concat(
    "assignee = ", assignee,
    " AND project = ", project,
    " AND issuetype = ", type,
    " AND affectedVersion = ", affectedversion)

| fieldsAdd jira_link = concat(
    "[Bugs](",target_url,
    replaceString(jql, " ", "+"),
    ")")

| fields product, version, jira_link

For Info, Error, and Resolved variants, build separate JQL fields with different issuetype or status values, then encode and link each one.

Target URL: https://github.com/{org}/{repo}

GitHub's issue search uses label-based filtering. Both product and version should be defined as labels on the GitHub issue.

Issue type	Search query
Info (open)	`is:issue is:open label:{product} label:{version}`
Error (bugs)	`is:issue is:open label:bug label:{product} label:{version}`
Resolved	`is:issue is:closed label:{product} label:{version}`

| fieldsAdd
    target_url = "https://github.com/{org}/{repo}",
    query_filter = concat("is:issue is:open label:", product, " label:", version)

| fieldsAdd enc_query = replaceString(replaceString(query_filter,     " ", "+"), ":", "%3A")

| fieldsAdd github_issues  = concat("[issue](",target_url,"/issues?q=",enc_query,")")
| fields product, version, github_issues

Both : and spaces need encoding for GitHub search URLs. Apply replaceString() for spaces first, then for colons. This order matters, because the intermediate result still contains spaces.

Target URL

https://gitlab.com/{group}/{project}, or
https://gitlab.{your-domain}.com/{group}/{project}

GitLab's issue search uses query parameters. label_name[] can appear multiple times to filter by multiple labels. The [] characters must be percent-encoded.

Issue type	Query parameters
Info (open)	`search={version}&label_name[]=info&label_name[]={product}&state=opened`
Error (bugs)	`search={version}&label_name[]=bug&label_name[]={product}&state=opened`
Resolved	`search={version}&label_name[]={product}&state=closed`

| fieldsAdd
    target_url = "https://gitlab.com/{group}/{project}",
    query_filter   = concat(
    "search=", version,
    "&label_name[]=bug",
    "&label_name[]=",  product,
    "&state=opened"
    )
| fieldsAdd enc_query = replaceString(replaceString(query_filter,    "[", "%5B"), "]", "%5D")
| fieldsAdd gitlab_issues = concat("[bugs](",target_url,"/-/issues?",enc_query,")")

| fields product, version, gitlab_issues

Apply replaceString() only to the query string part and not the full URL to avoid accidentally encoding [ or ] that appear elsewhere. Build the query string as an intermediate field first, encode it, then prepend the base URL in concat().

Base URL: https://{your-instance}.service-now.com

ServiceNow's incident list URL accepts a sysparm_query parameter using its own filter syntax. Conditions are chained with ^ (AND). The LIKE operator performs a contains match. You can query incidents by incident attribute values using the format <col_name><operator><value>. Any query that can be written as a sysparm_query request parameter is supported.

Example: correlation_displayLIKEDYNATRACE^active=true. This filters for records where the correlation_display column contains DYNATRACE and the record is active. For more information on other operators, see the ServiceNow API documentation.

| fieldsAdd
target_url = "https://{your-instance}.service-now.com",
query= concat(
    "short_descriptionLIKE", version,
    "^descriptionLIKE", product
    )

| fieldsAdd
    servicenow_incidents = concat("[servicenow_incidents](", target_url,"/now/nav/ui/classic/params/target/incident_list.do?sysparm_query=", query, ")")

| fields product, version, servicenow_incidents

URL encoding reference

If you need to adapt a pattern for a tool not listed above or encode additional characters, refer to the following reference.

DQL has no built-in URL-encode function, but replaceString() covers the cases that matter. Build the query string as a human-readable intermediate field first, then apply replaceString() to encode it before embedding it in the URL. This keeps the DQL readable and avoids manually typing percent-encoded sequences.

These encodings follow the RFC 3986 percent-encoding standard, and are not tool-specific. Each %XX is the uppercase hexadecimal ASCII code of the character (:=3A, [=5B, ]=5D, ==3D, <=3C, space=20). Any HTTP client or server decodes them correctly. The reason specific tools need specific characters encoded is that those characters carry special meaning in that tool's URL or query syntax; the encoding itself is not tool-specific.

Character	Encoded form	When needed	DQL
space	`+`	Always (spaces break markdown links)	`replaceString(field, " ", "+")`
`:`	`%3A`	GitHub search params (`is:issue`, `label:`)	`replaceString(field, ":", "%3A")`
`[` `]`	`%5B` `%5D`	GitLab `label_name[]` params	`replaceString(replaceString(field, "[", "%5B"), "]", "%5D")`

5. Configure the table visualization

In the table's visualization settings, set the link columns to the Markdown column type so Dynatrace renders [text](url) as clickable links. Without this setting, Dynatrace displays the raw markdown syntax, instead of a clickable link.
Activate line wrap on link columns to keep links readable when multiple values appear in a cell.

Congratulations!

Your tile now shows one row per product × version combination, with a deep link that opens your issue tracker pre-filtered for that release. For reference, the complete DQL for a Jira Cloud tile looks like this:

Show me the example

// Filter live-processes with release information
smartscapeNodes "PROCESS"
| filter isNotNull(tags[DT_RELEASE_VERSION]) and tags[DT_RELEASE_VERSION] != ""
| filter in(tags[DT_RELEASE_STAGE], array($Stage))
| filter in(tags[DT_RELEASE_PRODUCT], array($Product))
| filter in(tags[DT_RELEASE_VERSION], array($Version))
| dedup tags[DT_RELEASE_PRODUCT], tags[DT_RELEASE_VERSION]
| fields product = tags[DT_RELEASE_PRODUCT], version = tags[DT_RELEASE_VERSION]

// Define query parameter
| fieldsAdd
    target_url      = "https://{your-subdomain}.atlassian.net",
    project         = "{your-project-key}",
    assignee        = "currentuser()",
    type            = "Bug",
    affectedversion = version //dynamic field from release information filter

// Assemble filter query
| fieldsAdd jql = concat(
    "assignee = ", assignee,
    " AND project = ", project,
    " AND type = ", type,
    " AND affectedversion = ", affectedversion)
| fieldsAdd jira_link = concat(
    "[Bugs](",target_url,
    replaceString(jql, " ", "+"),
    ")")

// Define table columns
| fields product, version, jira_link

With that query in place, the tile renders a table like the following. Each link in the jira_link column opens Jira filtered to bugs for that specific product and version:

product	version	jira_link
ada	1.664.0	Bugs →
ada	1.665.0	Bugs →
ada	1.666.0	Bugs →
slo-service	1.1023.0	Bugs →
slo-service	1.1036.0	Bugs →
slo-service	1.1037.0	Bugs →
slo-service	1.1038.0	Bugs →
slo-service	1.1039.0	Bugs →
slo-service	1.952.0	Bugs →