- 11 minutes to read

Monitoring ACK/NAK Non-Events

Proactively monitor and manage ACK/NAK Non-Events with Nodinite to ensure your business never misses a critical response. This guide shows you how to configure, monitor, and act on ACK/NAK Non-Events, so you resolve issues before they impact your operations.

  • ✅ Instantly receive alerts for delayed or missing ACK/NAK responses
  • ✅ Monitor every ACK/NAK configuration as a unique resource
  • ✅ Detect duplicate responses and correlation issues automatically
  • ✅ Take immediate action with remote actions and clear state evaluation
  • ✅ Analyze alert history for rapid troubleshooting and continuous improvement

An order without its confirmation turns the ACK/NAK Resource Warning and then Error, animated walkthrough (7.12)
Animated walkthrough: an Order Received event is logged through the Log API without its Order Confirmation. The Contoso: Order confirmation ACK Resource goes Warning after the one-minute Warning time span, then Error after the two-minute Error time span, and Details shows the search window and the schedule.

Nodinite gives you the power to monitor, alert, and act on ACK/NAK Non-Events with unmatched precision. This guide explains what you monitor, how Nodinite translates technical events into actionable monitoring states, and how you use remote actions to resolve issues instantly. For a deeper dive into available Remote Actions, see the Managing ACK/NAK Non-Events user guide.

Monitoring Features

  • State Evaluation – Instantly receive alerts when thresholds are breached, so you never miss a critical event!
    • Duration Check – Get alerts when responses are late or missing, so you stay ahead of potential issues.
    • Correlation Count – Receive notifications if you detect too many responses, helping you quickly spot duplicates or anomalies.

Understanding ACK/NAK Monitoring

ACK/NAK (Acknowledgment/Negative Acknowledgment) monitoring tracks request-response patterns in your integration flows. This powerful feature ensures that every request receives the expected response within the defined time window.

What Is ACK/NAK Monitoring?

ACK/NAK monitoring correlates outgoing requests with incoming responses. You configure Nodinite to expect a specific number of responses (typically 1) for each request within a maximum duration. The system alerts you when:

  • Missing responses – A request has no corresponding ACK/NAK within the timeout period
  • Delayed responses – A response arrives after the warning threshold
  • Duplicate responses – More responses than expected arrive for a single request

Real-World Example

sequenceDiagram participant S as System A<br/>(Sender) participant I as Integration Platform participant R as System B<br/>(Receiver) participant N as Nodinite S->>I: 1. Send Order Request Note over S,I: LogEvent: Request sent<br/>Group key: OrderId = 12345 I->>R: 2. Forward to System B R->>I: 3. Send ACK Response Note over R,I: LogEvent: ACK received<br/>Group key: OrderId = 12345 I->>S: 4. Return ACK rect rgb(200, 220, 255) Note over N: Nodinite correlates using grouped Log View keys<br/>Request (10:00:00) + ACK (10:00:05)<br/>Duration: 5 seconds ✅ OK end

Diagram: Successful ACK/NAK correlation with response within acceptable timeframe.

How Correlation Works

Nodinite ACK/NAK monitoring uses one grouped Log Views result. The monitor evaluates events inside each group (business transaction/interchange) and checks that the next expected event arrives within configured time limits.

The configuration groups the Log View by a Search Field, such as O2C - Order ID, and lists the Message Types of the group in order, each with a Warning time span and an Error time span. Correlation comes from the grouped Log View design and the searchable values extracted from Log Events (payload/context). In practice, many solutions use an Application Interchange Id or similar business key, but it is not limited to one specific built-in field.

At runtime, the agent:

  • Queries the grouped Log View using the configured Log View API URI
  • Evaluates timing between related events in the same group
  • Applies Warning/Error time spans for delayed or missing expected events
  • Optionally evaluates the number of events in each group to detect anomalies and duplicates

Important

Copy the Log View API URI with the Log View's Copy API URL button. The URI must carry DataSource.LoadMessageTypeIds: true, which the copied URI does; without it, the agent's reports cannot name the Message Types.

ACK/NAK Example

Your e-commerce platform sends order confirmations to a fulfillment system. Each order must receive an acknowledgment within 30 seconds:

  • ⚠️ Warning threshold: 20 seconds – Response is slower than expected but acceptable
  • ❌ Error threshold: 30 seconds – Response is missing or critically delayed
  • Grouped correlation key: OrderId – Request and response stay in the same grouped transaction
  • Group count evaluation: Enable event-count checks when you also want duplicate/anomaly detection

Monitoring Outcomes

gantt title ACK/NAK Response Scenarios dateFormat HH:mm:ss axisFormat %H:%M:%S section Successful Flow Request sent (10:00:00) :milestone, 10:00:00, 0s ACK received (10:00:15) :done, 10:00:15, 0s Status: OK :active, 10:00:15, 1s section Warning Flow Request sent (10:05:00) :milestone, 10:05:00, 0s Warning threshold (10:05:20) :crit, 10:05:20, 0s ACK received (10:05:25) :done, 10:05:25, 0s Status: Warning (Delayed) :active, 10:05:25, 1s section Error Flow Request sent (10:10:00) :milestone, 10:10:00, 0s Warning threshold (10:10:20) :crit, 10:10:20, 0s Error threshold (10:10:30) :crit, 10:10:30, 0s No ACK received :active, 10:10:31, 1s Status: Error (Missing) :crit, 10:10:31, 1s

Diagram: Three ACK/NAK monitoring scenarios showing OK (green), Warning (yellow), and Error (red) states based on response timing.

State Evaluation for ACK/NAK Non-Events

Nodinite displays each ACK/NAK configuration as a unique Resource. For example, if you create 42 configurations, you monitor 42 distinct resources, each independently.

  • The Resource name matches the ACK/NAK configuration name.
  • All configurations appear under the 'ACK/NAK' Category.
  • The Application name is the configuration name too.

Contoso: Order confirmation ACK in Error in the ACK/NAK Category of a Monitor View (7.12)
You can easily view and manage all monitored ACK/NAK Non-Event configurations in a Nodinite Monitor View.

Nodinite continuously evaluates every ACK/NAK configuration (as a Resource) and assigns one of the following states:

State Status Description Actions
🚫 Unavailable Resource not available You cannot evaluate 'Non-Events ACK/NAK' due to network or security issues Review prerequisites
❌ Error Error threshold breached
  • One or more expected responses (ACK/NAK) are still missing after the Error time span
  • You detect too many events in group (duplicates detected)
Show missing events
Ignore previous errors
⚠️ Warning Warning threshold breached
  • One or more expected responses (ACK/NAK) are still missing after the Warning time span
  • A response arrived late; the Warning stays for the rest of the search window
  • You detect too many events in group (duplicates detected)
Show delayed events
Ignore previous errors
✅ OK Within user-defined thresholds You detect no late or missing responses Not applicable

With Nodinite, you can easily reconfigure state evaluation at the Resource level using the Expected State feature, so you tailor monitoring to your business needs.

Log Texts

State Log Text
⚠️ Warning, not answered yet Events found that have not yet received a response. The Warning threshold is 1 minute.
❌ Error, not answered Events found that have not yet received a response. The Error threshold is 2 minutes.
⚠️ Warning, answered late Events found that have a late response. The threshold is 1 minute

How ACK/NAK Duration Monitoring Works

Understanding how Nodinite evaluates ACK/NAK timing is essential for configuring accurate alerts.

Duration Calculation

Nodinite measures duration using timestamps from Log Events returned by the grouped Log Views. For request-response scenarios, this is typically the elapsed time from the request event to the corresponding response event within the same group.

Duration Formula

Duration = ExpectedNextEvent.LogDateTime - CurrentEvent.LogDateTime

Threshold Evaluation

You configure two duration thresholds:

Threshold Purpose Alert Level
⚠️ Warning Duration Acceptable but slower than optimal ⚠️ Warning
❌ Error Duration Unacceptable delay or timeout ❌ Error

Evaluation Logic

graph TD A[Request Log Event Created] --> B{Response Received?} B -->|Yes| C{Calculate Duration} B -->|No, within Warning Duration| D[Keep Monitoring] B -->|No, past Warning Duration| W[Warning: Not Answered Yet] B -->|No, past Error Duration| E[Error: Missing Response] W --> B C --> F{Duration <= Warning?} F -->|Yes| G[OK: Response on Time] F -->|No| I[Warning: Late Response<br/>for the rest of the search window] D --> B style G fill:#93d16d style W fill:#FFD525 style I fill:#FFD525 style E fill:#c33d34

Diagram: ACK/NAK duration evaluation flow. Green is OK, yellow is Warning, and red is Error: a missing response escalates from Warning to Error, and a response that arrives late completes the group with a Warning.

Example Timeline

Example Configuration

  • Warning Duration: 00:00:20 (20 seconds)
  • Error Duration: 00:00:30 (30 seconds)

Scenario 1: Successful Response

10:00:00 - Request sent (LogDateTime)
10:00:12 - ACK received (LogDateTime)
Duration: 12 seconds
Result: ✅ OK

Scenario 2: Delayed Response

10:05:00 - Request sent
10:05:20 - No response yet (past the warning duration): Warning
10:05:25 - ACK received (after warning, before error)
Duration: 25 seconds
Result: ⚠️ Warning (Response delayed but received)

Scenario 3: Missing Response

10:10:00 - Request sent
10:10:31 - Still no response (exceeded error duration)
Duration: >30 seconds
Result: ❌ Error (Missing response)

Scenario 4: Very Late Response

10:15:00 - Request sent
10:15:30 - Still no response: Error
10:15:45 - ACK received (after error threshold)
Duration: 45 seconds
Result: ⚠️ Warning (late response) for the rest of the search window

Group Count Evaluation and Duplicate Detection

ACK/NAK monitoring can evaluate event counts per group to identify correlation issues and retry storms.

Evaluate Number of Events in the Group

Enable Evaluate the number of events in the group to apply thresholds on grouped transactions and detect abnormal patterns.

Common outcomes:

  • Too few events in a group can indicate missing steps
  • Too many events in a group can indicate duplicates, retries, or replay issues
  • Combined with duration thresholds, you can detect both late/missing responses and count anomalies

Retry Scenario

Your payment gateway occasionally retries acknowledgments due to transient network conditions. By combining count evaluation and duration thresholds, you can tolerate expected retry behavior while still alerting on abnormal duplicate patterns.

Duplicate Detection Example

sequenceDiagram participant R as Grouped Log View participant N as Nodinite participant A as Grouped Events R->>N: Event #1: OrderID-123<br/>10:00:00 A->>N: Event #2: OrderID-123<br/>10:00:05 Note over N: 1 response ✅ OK A->>N: Event #3: OrderID-123<br/>10:00:06 Note over N: Additional event in same group<br/>Review count thresholds A->>N: Event #4: OrderID-123<br/>10:00:07 Note over N: Additional event in same group<br/>Possible retry/replay A->>N: Event #5: OrderID-123<br/>10:00:08 rect rgb(255, 220, 220) Note over N: Group count exceeds configured threshold<br/>Warning/Error raised end

Diagram: Grouped event count evaluation showing progression from OK to Warning state as duplicates exceed configured thresholds.

Remote Actions

Take control with powerful remote actions directly from your monitoring dashboard. The Action menu of an ACK/NAK Resource holds Show Log View, Details, Show missing events, Show delayed events, and Ignore previous errors:

When to Use Each Action

Action Use Case Example
Show missing events Investigate lost messages or system downtime "Why didn't the fulfillment system acknowledge 15 orders between 2-3 PM?"
Show delayed events Analyze performance degradation "Which responses took longer than 20 seconds this week?"
Ignore previous errors Reset monitoring state after resolving issues "The service is back online, clear old alerts to start fresh monitoring"

Edit Thresholds

An ACK/NAK Resource has no Edit action. Change the Warning and Error time spans, and the group-count evaluation thresholds, on the Evaluation tab of the ACK/NAK entry in the Remote Configuration (see Edit an ACK/NAK configuration and the Configuration user guide), to match your business SLAs.

Alert History for ACK/NAK Non-Events

You can analyze the frequency and pattern of ACK/NAK Non-Event issues for root cause analysis and continuous improvement. Nodinite lets you search historical state changes for any time span, across all or individual configurations. Learn more in Add or manage Monitor View.

Search Resource history
Search History (7.12)
Search for alert history for all resources in the Monitor View
Resource history of Contoso: Order confirmation ACK with Warning, Error, and OK entries (7.12)
Alert history for the selected ACK/NAK configuration

Frequently Asked Questions

Find answers to common questions and troubleshooting tips in the Troubleshooting guide.

How Do I Enable Monitoring of ACK/NAK Non-Events?

To monitor an ACK/NAK configuration, check Enable on the Basic tab of its entry in the remote configuration. See the 'Configuration' user guide for details.

The screenshot below shows the remote configuration form from the Monitoring Agents administration page.
Basic tab of the ACK/NAK entry Contoso: Order confirmation ACK with Enable cleared (7.12)
This example shows a disabled ACK/NAK monitoring configuration.

What's the difference between ACK/NAK and Non-Events monitoring?

ACK/NAK Monitoring focuses on request-response correlation:

  • Tracks individual request-response pairs
  • Monitors response timing (duration)
  • Detects missing, delayed, or duplicate responses
  • Uses grouped Log View keys to match related events
  • Best for: API acknowledgments, message confirmations, two-way integrations

Non-Events Monitoring focuses on volume patterns:

  • Tracks total event counts over time periods
  • Monitors whether counts fall within expected ranges
  • Detects too many or too few events
  • Uses time-based intervals (hourly, daily, monthly)
  • Best for: Batch processing, scheduled jobs, overall system health

Example Comparison

Scenario Use ACK/NAK Use Non-Events
"Did each customer order receive an acknowledgment?" ✅ Yes
"Are acknowledgments arriving within 30 seconds?" ✅ Yes
"Are we processing 1000-1500 orders per day?" ✅ Yes
"Did the nightly batch job run?" ✅ Yes
"Are we receiving exactly one confirmation per invoice?" ✅ Yes

Why am I getting duplicate warnings when retries are expected?

Tune your group-count evaluation thresholds to accommodate normal retry behavior. For example, if your flow can legitimately emit extra events during retries:

  • Keep your Warning and Error time spans unchanged for delay detection
  • Adjust count evaluation to tolerate expected extra events in the same group

This setup reduces noise from expected retries while still alerting on abnormal duplicate/replay patterns.

Can I use ACK/NAK monitoring without exact correlation IDs?

Yes, but you still need a stable grouping key in your grouped Log View. ACK/NAK monitoring does not require a field literally named Application Interchange Id; it requires consistent values that keep related events in the same group.

Use this approach:

  1. Extract business identifiers with Search Fields for all involved message types
  2. Build the grouped Log View so request and response events land in the same group
  3. Validate grouping behavior in the Log View before enabling ACK/NAK monitoring

If you cannot establish reliable grouping keys, use Non-Events monitoring for volume-pattern monitoring instead.

How far back does Nodinite look for responses?

Nodinite uses the Search time span configured on the Basic tab of the ACK/NAK entry. This defines how far back to search for matching requests when evaluating responses. Override start date time (UTC), which Ignore previous errors sets, moves the start of that window forward.

Search Time Span Example

  • Search time span: 7.00:00:00 (7 days)
  • During evaluation, Nodinite inspects grouped events within the past 7 days

Best practice: Set the search time span to at least 2-3 times your error duration to ensure Nodinite can find delayed responses.

Next Steps