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:

• Redis

• DynamoDB

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:

• Redis - Filtering based on method or command

• DynamoDB - Filtering based on method or command

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

• Instana Node.js monitoring

• Configuring ignoring endpoints

• @instana/collector package on npm

#Tracing