Try it free

Upgrade from Classic runtime metrics to Grail

  • Latest Dynatrace
  • Upgrade guide

This guide provides insights into migrating runtime metrics to Grail, so you can smoothly transition to Latest Dynatrace.

Why upgrade?

  • Full power of Grail: Upgrading your queries lets you use runtime metrics on Grail in Notebooks Notebooks, Dashboards Dashboards, and other Dynatrace apps.
  • Advanced query capabilities: Metrics on Grail use DQL, which lets you filter, aggregate, join, and transform data in a single query.

What will you do?

  • Identify how your Classic runtime metric maps to Grail: divergent, convergent, or unsupported.
  • Look up your Classic metric key in the tables below and find its Grail equivalent.
  • Convert your metric selector queries to DQL using the mapping tables and examples.

Before you begin

Prerequisites

  • Access to Notebooks Notebooks or Dashboards Dashboards to test and validate your converted DQL queries.

Prior knowledge

  • Familiarity with Metrics Classic and metric selector syntax.
  • Basic understanding of DQL concepts.
  • Familiarity with creating DQL queries in Notebooks Notebooks or Dashboards Dashboards.
  • Understanding of the metric mapping types used in this guide: divergent, convergent, and unsupported.

How to upgrade

To convert a Classic runtime metric query:

  1. Find your Classic metric key in the metric key reference below.
  2. Note its Grail equivalent.
  3. Write a DQL query that uses the relevant Grail metric key.

Because there isn't an exact, one-to-one mapping between Classic metric selectors and DQL queries, some queries will require manual adjustments during the conversion.

Metric key reference

The following tables list Classic technology runtime metric keys and their Grail equivalents, organized by mapping type. Select the section that matches your technology.

For more information about metric mapping, see New concepts.

Divergent metrics

Because Grail metrics are technology-specific, there's no direct relation between Metrics Classic and Grail metrics. You need to choose a technology-dedicated metric in Grail.

Example equivalent Classic metric selector and DQL query

The following Classic metric selector and DQL query return equivalent results.

Classic metric selectorDQL query
builtin:tech.jvm.memory.gc.collectionTime:filter(and(or(in("dt.entity.process_group_instance",entitySelector("type(process_group_instance),entityName.equals(~"MyGoProcessGroup-IG-1~")"))))):auto
timeseries collection_time = sum(dt.runtime.go.gc.collection_time),
filter:in(dt.entity.process_group_instance, classicEntitySelector("type(process_group_instance), entityName.equals(\"MyGoProcessGroup-IG-1\")"))

JVM-based metrics

The following Metrics Classic metrics for memory pool and garbage collection are JVM-based. You need to choose the relevant Java, Node.js, or .NET metric in Grail.

Classic metric keyGrail metric keys
builtin:tech.jvm.memory.gc.collectionTimedt.runtime.jvm.gc.total_collection_time
dt.runtime.clr.gc.collection_time
dt.runtime.go.gc.collection_time
builtin:tech.jvm.memory.pool.collectionTimedt.runtime.jvm.gc.collection_time
dt.runtime.nodejs.gc.collection_time
builtin:tech.jvm.memory.gc.suspensionTimedt.runtime.jvm.gc.suspension_time
dt.runtime.clr.gc.suspension_time
dt.runtime.go.gc.suspension_time
dt.runtime.nodejs.gc.suspension_time

Web server metrics

The following Classic metrics for web servers hold values for different technologies. You need to choose the dedicated Apache, IIS, or NGINX metric in Grail.

Classic metric keyGrail metric keys
builtin:tech.webserver.connections.socketWaitingTimedt.runtime.apache.connections.socket_waiting_time
dt.runtime.iis.connections.socket_waiting_time
builtin:tech.webserver.requestsdt.runtime.apache.requests
dt.runtime.iis.requests
dt.runtime.nginx.requests
builtin:tech.webserver.threads.activedt.runtime.apache.threads.active
dt.runtime.iis.threads.active
builtin:tech.webserver.threads.idledt.runtime.apache.threads.idle
dt.runtime.iis.threads.idle
builtin:tech.webserver.threads.maxdt.runtime.apache.threads.max
dt.runtime.iis.threads.max
builtin:tech.webserver.trafficdt.runtime.apache.traffic
dt.runtime.iis.traffic
dt.runtime.nginx.traffic

Convergent metrics

Some Grail metric keys contain values that were previously stored across multiple Classic metric keys. These are stored in Grail as dimensions.

Example equivalent Classic metric key and DQL query

The following Classic metric key and DQL query return equivalent results.

Classic metric keyDQL query

builtin:tech.go.http.responses5xx

timeseries responses5xx = sum(dt.runtime.go.http.requests),
filter:{500 <= status and status <= 599}
Classic metric keysGrail metric keyFilter by
builtin:cloud.cloudfoundry.auctioneer.lprFailed (filtered by process type Go)
builtin:cloud.cloudfoundry.auctioneer.lprStarted (filtered by process type Go)
dt.runtime.go.cf.auctioneer_lrp_auctionsfilter:{status == "failed"}
filter:{status == "started"}
builtin:tech.go.http.badGateways
builtin:tech.go.http.responses5xx
builtin:tech.go.http.totalRequests
dt.runtime.go.http.requestsfilter:{status == 502}
filter:{status >= 500 and status <= 599}
builtin:tech.go.memory.heap.idle
builtin:tech.go.memory.heap.live
dt.runtime.go.memory.heapfilter:{state == "idle"}
filter:{state == "live"}
builtin:tech.go.scheduling.g.runningCount
builtin:tech.go.scheduling.g.systemCount
dt.runtime.go.scheduler.goroutine_countfilter:{owner == "user"}
filter:{owner == "system"}
builtin:tech.go.scheduling.m.count
builtin:tech.go.scheduling.m.idlingCount
builtin:tech.go.scheduling.m.spinningCount
dt.runtime.go.scheduler.worker_thread_countfilter:{state == "Overall"}
filter:{state == "Idling"}
filter:{state == "Spinning"}
builtin:tech.dotnet.gc.gen0Collections
builtin:tech.dotnet.gc.gen1Collections
builtin:tech.dotnet.gc.gen2Collections
dt.runtime.clr.gc.collection_countfilter:{generation == "Generation0"}
filter:{generation == "Generation1"}
filter:{generation == "Generation2"}
builtin:tech.dotnet.memory.gen0Consumption
builtin:tech.dotnet.memory.gen1Consumption
builtin:tech.dotnet.memory.gen2Consumption
builtin:tech.dotnet.memory.LOHConsumption
dt.runtime.clr.memory.consumptionfilter:{generation == "Generation0"}
filter:{generation == "Generation1"}
filter:{generation == "Generation2"}
filter:{generation == "LargeObjectHeap"}
builtin:tech.dotnet.threadpool.ioCompletionThreads
builtin:tech.dotnet.threadpool.workerThreads
dt.runtime.clr.threadpool.threadsfilter:{type == "activeIOCompletionThreads"}
filter:{type == "activeWorkerThreads"}

Unsupported metrics

The following Metrics Classic metrics don't have a dedicated Grail metric.

  • builtin:tech.nginx.cache.hitRatio

    Equivalent DQL query
    timeseries
    misses = sum(dt.runtime.nginx.plus.cache.misses),
    hits = sum(dt.runtime.nginx.plus.cache.hits)
    | fieldsAdd hit_ratio = misses[] / hits[]
  • builtin:tech.nginx.serverZones.active

  • builtin:tech.nginx.serverZones.inactive

  • builtin:tech.nodejs.uvLoop.count

  • builtin:tech.nodejs.uvLoop.loopLatency

  • builtin:tech.nodejs.uvLoop.processedLatency

  • builtin:tech.nodejs.uvLoop.totalTime

Related topics

  • Use DQL queries
  • Notebooks
Related tags
Dynatrace Platform