Try it free

Upgrade from Classic runtime metrics to Grail

  • Dynatrace Classic
  • Upgrade guide
  • 3-min read

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.collectionTime

  • dt.runtime.jvm.gc.total_collection_time
  • dt.runtime.clr.gc.collection_time
  • dt.runtime.go.gc.collection_time

builtin:tech.jvm.memory.pool.collectionTime

  • dt.runtime.jvm.gc.collection_time
  • dt.runtime.nodejs.gc.collection_time

builtin:tech.jvm.memory.gc.suspensionTime

  • dt.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.socketWaitingTime

  • dt.runtime.apache.connections.socket_waiting_time
  • dt.runtime.iis.connections.socket_waiting_time

builtin:tech.webserver.requests

  • dt.runtime.apache.requests
  • dt.runtime.iis.requests
  • dt.runtime.nginx.requests

builtin:tech.webserver.threads.active

  • dt.runtime.apache.threads.active
  • dt.runtime.iis.threads.active

builtin:tech.webserver.threads.idle

  • dt.runtime.apache.threads.idle
  • dt.runtime.iis.threads.idle

builtin:tech.webserver.threads.max

  • dt.runtime.apache.threads.max
  • dt.runtime.iis.threads.max

builtin:tech.webserver.traffic

  • dt.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_auctions

  • filter:{status == "failed"}
  • filter:{status == "started"}
  • builtin:tech.go.http.badGateways
  • builtin:tech.go.http.responses5xx
  • builtin:tech.go.http.totalRequests

dt.runtime.go.http.requests

  • filter:{status == 502}
  • filter:{status >= 500 and status <= 599}
  • builtin:tech.go.memory.heap.idle
  • builtin:tech.go.memory.heap.live

dt.runtime.go.memory.heap

  • filter:{state == "idle"}
  • filter:{state == "live"}
  • builtin:tech.go.scheduling.g.runningCount
  • builtin:tech.go.scheduling.g.systemCount

dt.runtime.go.scheduler.goroutine_count

  • filter:{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_count

  • filter:{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_count

  • filter:{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.consumption

  • filter:{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.threads

  • filter:{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