As Node.js applications scale, maintaining their performance visibility becomes more important. However, managing the volume of trace data collected also becomes critical. Tracing everything can lead to higher ingestion costs, reduced system performance, and dashboards cluttered with low-value data. To help teams focus on what truly matters, IBM Instana introduces a feature that allows developers to exclude specific endpoints from tracing in Node.js applications. This targeted approach enables more resource-efficient monitoring while still delivering deep insights needed to optimize application health and performance.
Introducing ignoring endpoints for Node.js
The Instana’s ignoring endpoints feature (available in @instana/collector version 4.7.0 and later) allows developers to opt out of certain low-priority operations from tracing. Currently, the feature supports:
By excluding specific commands from tracing, you can streamline observability, improve application performance, and reduce trace storage.
How to configure ignoring endpoints
You can configure ignore endpoints in three ways, depending on your environment and preferences:
1. Environment variable
Using a configuration file (INSTANA_IGNORE_ENDPOINTS_PATH)
You can configure ignoring endpoints by setting the INSTANA_IGNORE_ENDPOINTS_PATH
environment variable to the absolute path of a YAML configuration file.
INSTANA_IGNORE_ENDPOINTS_PATH=/absolute/path/to/config.yaml
Example: config.yaml
tracing:
ignore-endpoints:
redis:
- get
- type
dynamodb:
- query
- scan
This configuration excludes the Redis GET
and TYPE
commands, as well as the DynamoDB QUERY
and SCAN
operations from being traced.
Using INSTANA_IGNORE_ENDPOINTS
A fast and deployment-friendly method. Simply set the INSTANA_IGNORE_ENDPOINTS environment variable.
Example 1: Exclude Redis GET and TYPE
INSTANA_IGNORE_ENDPOINTS=redis:get,type
Example 2: Exclude Redis GET and TYPE, and DynamoDB QUERY and SCAN
INSTANA_IGNORE_ENDPOINTS=redis:get,type;dynamodb:query,scan
2. In-Code configuration
This approach is ideal when you require more granular control over ignoring endpoints directly within your application logic.
Example:
require('@instana/collector')({
tracing: {
ignoreEndpoints: {
redis: ['get', 'type'],
dynamodb: ['query', 'scan']
}
}
});
This configuration provides the flexibility to adjust ignored commands dynamically based on application logic.
3. Agent configuration
Best suited for centralized and large-scale deployments. Add the ignored endpoints to configuration.yaml file in the Instana agent.
Example:
com.instana.tracing:
ignore-endpoints:
redis:
- get
- type
dynamodb:
- query
- scan
This approach ensures consistent configuration across multiple services and environments. For further details, please refer to the ignoring endpoints using the agent section in our official documentation.
NOTE:
Command and methods names may vary depending on the programming language or technology in use. To accurately exclude the intended methods, review the Instana UI analytics page and examine the trace details to identify the exact method or command name you want to ignore.

Trace view before and after
The following images demonstrate how excluding specific endpoints, such as Redis GET and TYPE commands, impacts the trace visualization in the Instana UI:
Before:
The trace includes Redis operations such as GET, SET, and TYPE, contributing to increased trace volume and potential noise.

After:
Redis GET and TYPE operations are excluded from the trace, leading to a cleaner view that emphasizes critical service interactions.

When to use ignoring endpoints
Ignoring endpoints is most beneficial when tracing certain operations provides limited value or adds overhead. Consider this feature in the following scenarios:
-
High-frequency and low-risk operations
For example, Redis GET or DynamoDB SCAN used in caching or metadata lookups.
-
Reducing trace noise
To declutter dashboards and highlight high-impact interactions.
-
Lowering data ingestion and cost
Especially useful in observability setups with budget or ingestion limits.
-
Improving application performance
Tracing fewer spans can reduce instrumentation overhead and latency.
Impacts and considerations
While ignoring endpoints is highly effective, be aware of the potential trade-offs:
-
Missed spans: Traces for excluded operations will not be recorded or visible in Instana.
-
Trace correlation gaps: Excluding intermediate calls can break trace continuity, especially in distributed systems. However, for exit spans such as DynamoDB calls, trace correlation remains intact since they are typically the final span in the trace tree, with no additional spans connecting to them.
Use this feature thoughtfully, and avoid excluding critical parts of the application flow that are necessary for debugging or correlation.
Limitations
The ignoring endpoints feature currently supports only a few packages:
This functionality is available starting from @instana/collector version 4.7.0. Support for additional packages and operations may be added in future updates.
Summary
Instana’s ignoring endpoints feature for Node.js offers a strategic way to reduce trace data volume, optimize application performance, and focus on high-value monitoring. With support for Redis and DynamoDB, and configuration options across environment variables, code and agent settings, this feature brings both flexibility and control.
While it helps streamline observability, make sure that it is applied selectively to avoid losing visibility into key system interactions.
Related documentation
#Tracing