Service detection and naming

Dynatrace automatically detects and names your applications' server-side services based on some basic properties of your application deployment and configuration. In case the default naming scheme does not cover your particular needs, you can customize the naming of your services.

As service landscapes can become quite complex, Dynatrace automatically categorizes services based on their dependencies to other entities like services or applications.

Dynatrace automatically groups related processes into process groups. When Dynatrace detects multiple process groups, it assumes that the process groups represent separate applications, or at least separate logical parts of a single application. Process groups therefore represent boundaries for the services they contain.

When Dynatrace detects the same service in multiple processes within the same process group, it represents the service as a single service running on multiple processes or hosts. Conversely, if Dynatrace detects a seemingly identical service in multiple process groups, it represents the separate service instances as separate services, even though the services appear to be the same. For this reason it sometimes makes sense to customize how Dynatrace detects process groups.

Web request services

Web request services serve the web applications that you deploy either via a web server (for example, Apache, IIS, or NGINX) or within web containers (for example, Java, .NET, Node.js, or PHP). Dynatrace considers three discrete concepts when identifying and naming web services: Web server name, Context root, and Web application ID.

You can find these attributes in the Properties and tags of the service overview page.

Dynatrace picks up some or all of these properties and then creates a unique service based on them. When Dynatrace finds a web application ID, it uses the ID as the default service name. In other cases, web request services are named based on the web server name + the context root. This means that if you give an IIS site a proper name or define a name for your web application in web.xml or package.json, Dynatrace will pick up the name you specify.

Web services

Web services are defined by Web Services Description Language (WSDL), which is part of your deployment. WSDL defines services, how services are called, and service names. Dynatrace picks up service names along with targetNamespace values and combines these values to uniquely identify each service.

Dynatrace detects web services based on technology-specific frameworks. For details on the web-service frameworks that are monitored by Dynatrace out-of-the-box, see supported web service frameworks for Java and .NET.

Sometimes it's technically not possible to easily detect a web service name. In such cases Dynatrace uses the web service endpoint rather than the name.

Database services

When Dynatrace detects that your application makes database requests, it identifies the name of the database or schema, the database vendor, and the IP address/port of the database. It uses this information to define a unique monitored database service and, where possible, detect on which process the database service runs.

For the full list of database services that are supported by Dynatrace, see supported database services.

Messaging and queueing

Dynatrace detects queue and message listeners in your applications and identifies them based on listener class name. See supported messaging services.

Queue listener services

Queue listener services tell you which queues you're listening to. These are lightweight services that don't have response times. These services tell you how many messages a queue has dequeued. They don't tell you anything about message processing—messaging services do that.

If Dynatrace automatically detects an event-based message listener, a queue listener service is always followed by a messaging service, which gives you insight into messages details. However, if you're just monitoring a queue, and not looking into message details, the queue listener service may exist on its own.

Messaging services

Messaging services process messages from a queue. A message service is always preceded by a queue listener service, which listens to the queue the message came from.

If your application dequeues messages in a busy loop, Dynatrace can't detect automatically how the messages are processed. To get insight for that, you can create a custom service for the message processing.

Remoting services

Remoting services are divided into two categories:

  • Remote method invocation (RMI)
  • Remote procedure call (RPC)

For a list of remoting services supported by Dynatrace, see supported remoting services.

RMI service

In the world of Java, Remote Method Invocation (RMI) is a common means of communication used by JVMs. As there may be many dynamically-created RMI servers within a single JVM, Dynatrace creates only a single RMI service for each process group. However, this doesn't mean that you lose visibility into your RMI services; Dynatrace tracks and monitors each RMI class as a separate request type.

RPC service

Dynatrace tracks remote procedure calls by SDKs, Akka, and AWSLambda. Unlike RMI, Dynatrace creates a separate RPC service for each service endpoint.

Background activity services

In many cases services are called by threads that run in the background of your application or another application. These requests, executed in background threads, represent the background activity of monitored process groups that make calls to other services. They also track outgoing messages in queues.

For example, if you have a background thread in a Tomcat that makes web requests to Apache, Dynatrace represents this as an background activity service of Tomcat. You'll be able to see which requests Tomcat is making to your Apache by analyzing the response time of the background activity service of Tomcat.

Custom services

Custom services allow you to instrument an application that is not built on standard technologies. You can also fine-tune your system, and instrument a particular method, class, or interface you're interested in. You can create custom services for Java, .NET, and PHP.

To learn how to create custom services, see Define custom services.

O* default service

The O* default service is created when Dynatrace detects a service call to a span attachment. This is just a placeholder service that's required to build a valid tree structure. Note that Dynatrace currently doesn't support service detection for spans.

Adjusting service detection

Web server naming issues

In some cases, web servers don't have well-defined virtual hosts, server names, or sites. A web server may simply be named localhost. This can result in multiple similar services that contain multiple web site instances. To remedy such issues, adjust process-group detection settings.

When there is no virtual host configured in an Apache HTTP server, the web server name defaults to the name of the physical host. In cloud environments, this leads to one virtual host for each physical host instance and thus one service instance. If the cloud environment starts and stops the hosts, these services will be temporary.

To remedy such localhost scenarios, use an environment variable to define virtual host names. Simply set DT_LOCALTOVIRTUALHOSTNAME for each web server process to any value. Dynatrace will pick up the names and use them in place of the existing localhost virtual host names. With this approach, you can ensure that multiple physical hosts report the same virtual host and thus get one service with multiple instances, one instance per physical host.

Define web application IDs

Some technologies don't provide unique application names. In such cases, you can define an environment variable called DT_APPLICATIONID to provide a unique name. This only impacts services of the respective process that don't already have application IDs. For Java applications, you can alternatively use the system property dynatrace.application.id.

Rotating and anonymous ports

Dynatrace takes the listen port of each web request service into account when naming and detecting requests. In some cases, these ports are meaningless or random, changing with each restart. This is especially true if you're using a load balancer that dynamically assigns ports to application processes, as is the case in many Node.js scenarios.

To remedy this, you can set the environment variable DT_IGNOREDYNAMICPORT=true. This removes the port from the detection and replaces it with *.