500-420 Collectors, Information Points, and Service Endpoints

Collectors, Information Points, and Service Endpoints Detailed Explanation

This knowledge area focuses on advanced monitoring tools in AppDynamics that provide deeper insights into application performance by tracking specific details beyond standard business transactions.

Collectors

What Are Collectors?

• Collectors are used to capture specific data during transaction execution, such as:
  • HTTP headers
  • URL parameters
  • Custom request parameters

Functionality

• Collectors extract contextual data from transactions to provide more detailed information for analysis.
• For example, in an e-commerce system:
  • A collector can capture the "user ID" from a transaction to help analyze performance for specific users.

Use Cases

• Debugging Specific Issues:
  • If some users report slow performance, a collector capturing user IDs can identify transactions associated with those users.
• Custom Metrics:
  • Capture custom attributes like session IDs or payment types to correlate transaction performance with business logic.

Example:

1. Scenario:
   • You want to track which products users are adding to their shopping carts.
2. Action:
   • Configure a collector to capture the "product ID" from HTTP requests in the "Add to Cart" transaction.
3. Result:
   • The collected data helps identify whether performance issues are linked to specific products.

Information Points

What Are Information Points?

• Information Points are monitoring tools that track the performance of specific code methods or business logic without being tied to a full transaction.
• They allow for customized monitoring of important application components.

Use Cases

1. Monitor Specific Methods:
   • Track how often a specific method is called and how long it takes to execute.
   • Example: Monitoring a method that calculates shipping costs.
2. Measure Business Logic Performance:
   • Focus on critical business functions that are not part of an auto-detected transaction.
   • Example: Tracking how long it takes for an algorithm to generate a product recommendation.

Scenarios

• Non-transactional Monitoring:
  • Information Points are ideal for monitoring performance outside the scope of traditional transactions.
• Debugging Long-Running Code:
  • Identify slow-performing methods in complex applications.
• Tracking Execution Counts:
  • Monitor how often a specific method is triggered to analyze usage patterns.

Example:

1. Scenario:
   • You have a method calculateShippingCost() that isn’t part of any major transaction.
2. Action:
   • Define an Information Point for calculateShippingCost() to monitor:
     • Execution time
     • Frequency of calls
3. Result:
   • The data reveals that shipping cost calculations spike during promotions, helping identify areas for optimization.

Service Endpoints

What Are Service Endpoints?

• Service Endpoints monitor the performance of individual service calls (e.g., REST APIs, web services) independently of transactions.
• They provide granular insights into the performance of specific services.

Metrics Monitored

1. Response Times:
   • Tracks how long it takes for a service to respond to a request.
   • Example: Monitoring the response time of a payment gateway API.
2. Call Frequency:
   • Monitors how many times the service is called.
   • Example: Tracking how often the "Check Inventory" service is used.
3. Failure Rates:
   • Identifies the percentage of failed service calls.
   • Example: Detecting if a login API frequently times out.

Optimizing Services

1. Identify Slow Service Calls:
   • Pinpoint which services have the highest response times or error rates.
   • Example: If an external API for product recommendations takes too long, consider caching the data locally.
2. Balance Workloads:
   • Use data on call frequency to redistribute workloads across servers or services.
3. Improve Error Handling:
   • Reduce failure rates by improving error handling and retry mechanisms.

Practical Example: Combining Tools

Scenario:

You manage an online ticket booking platform. Customers report delays in the booking process.

Step 1: Use Collectors

• Goal: Capture contextual data, like "user ID" and "event ID," to identify which transactions are affected.
• Action: Configure a collector to capture these details from HTTP request headers.

Step 2: Use Information Points

• Goal: Monitor the method reserveSeats() to determine if it is causing delays.
• Action: Create an Information Point to track how long the method takes to execute during peak times.

Step 3: Use Service Endpoints

• Goal: Monitor the API call to the payment gateway, as it’s a critical service for booking tickets.
• Action: Set up a Service Endpoint to track:
  • Response times
  • Error rates
  • Call frequency

Results:

• The collector reveals that delays are concentrated among high-traffic events.
• The Information Point shows that reserveSeats() takes 2 seconds longer than usual due to increased load.
• The Service Endpoint indicates that the payment gateway occasionally times out during high demand.

Solution:

• Optimize the reserveSeats() method by improving database indexing.
• Implement a retry mechanism for the payment gateway API.

Summary

• Collectors: Capture custom data like request parameters for contextual insights.
• Information Points: Monitor specific methods or business logic that aren't part of transactions.
• Service Endpoints: Track and optimize performance for individual services, such as APIs or web services.

Using these tools together provides a comprehensive view of application performance, helping you troubleshoot and optimize efficiently.

Collectors, Information Points, and Service Endpoints (Additional Content)

These three tools in AppDynamics offer advanced, targeted monitoring capabilities beyond basic Business Transactions. They are especially useful when you need to monitor custom logic, key method execution, or external service APIs.

Comparison Table: Functional Differences

Feature	Collectors	Information Points	Service Endpoints
Purpose	Capture request or context-specific parameters	Monitor performance of specific methods	Track API or service-level performance
Tied to BT?	Yes	No	No
Primary Metrics	Custom request values, user/session data	Method execution time, invocation count	Response time, call frequency, failure rate
Typical Use Cases	Capture user ID, product ID, session info	Track recommendation logic or shipping algorithm	Monitor login API, detect timeouts, retry issues

Detailed Use Case Overview

Collectors

• Where used: Inside Business Transactions

• Why used: To extract meaningful context data (e.g., user ID, cart value)

• Key Value: Helps correlate performance to specific users, actions, or business inputs

Information Points

• Where used: On any method, even outside BTs

• Why used: Monitor methods that do important background or internal logic

• Key Value: Gain visibility into non-transactional components affecting user experience

Service Endpoints

• Where used: On service entry points (e.g., REST, SOAP, gRPC)

• Why used: Capture key metrics of API/service interfaces, even if not linked to BTs

• Key Value: View how often an endpoint is called, its average response time, and error rate

Configuration Steps

1. Configuring a Collector

Steps:

1. Navigate to the Application in the Controller.

2. Go to Configuration > Instrumentation > Data Collectors.

3. Choose HTTP Parameter, Servlet, or Method Invocation type.

4. Set the rules:

• E.g., for HTTP: capture userID from the query string or headers.

5. Assign it to a Business Transaction or tier.

6. Save and apply changes.

Result:

Captured values will appear in the Transaction Snapshots, helping correlate performance with user-specific data.

2. Configuring an Information Point

Steps:

1. Go to the Application dashboard.

2. Select Configuration > Instrumentation > Information Points.

3. Choose the Java class and method to monitor (e.g., ShippingCalculator.calculate()).

4. Define the tier(s) where this method is used.

5. Save and restart the agent or application (if needed).

Result:

You’ll be able to see:

• Average execution time

• Invocation counts

• Trend charts

These appear in the Information Points section under Application Flow Maps or Dashboards.

3. Configuring a Service Endpoint

Steps:

1. Open the Application in the Controller.

2. Navigate to Service Endpoints > Configuration.

3. Select the tier (e.g., API Gateway tier).

4. Define matching criteria for the service call:

• Method name

• Servlet path

• URI regex

5. Provide a name (e.g., Payment API - Auth).

6. Save the configuration.

Result:

You can view response time, error rates, and calls per minute independently of full transaction traces.

Summary: When to Use What

Need	Tool to Use
Capture request-specific data	Collector
Monitor logic outside standard BTs	Information Point
Track service/API performance	Service Endpoint
Correlate user-specific performance data	Collector
Detect long-running internal methods	Information Point
Analyze retry/failure in external APIs	Service Endpoint