Issue detection

OpsAI Issue Detection brings supported infrastructure, Kubernetes, and application issues into one list in Middleware.

Once Middleware starts collecting telemetry through the Infrastructure Agent, Kubernetes Agent, APM SDK, or RUM SDK, OpsAI detects supported errors and performance issues and displays them in a single issue list.

Use the issue list to identify affected resources, assess recurring problems, and choose which issue to investigate first.

How Issue Detection Works#

OpsAI analyzes telemetry collected from your monitored environment to identify issues.

It uses signals such as:

• Infrastructure and Kubernetes telemetry
• Application errors and traces
• Frontend errors
• Logs and stack traces
• Performance issues and regressions
• Middleware alerts and supported third-party alerts

When a supported issue is detected, OpsAI creates an issue entry and makes it available for investigation.

Related issue occurrences can be grouped to help reduce duplicate entries and simplify investigation.

View Detected Issues#

Open the Middleware Home screen.

The main issue list displays detected problems across your monitored environment.

Use this page to review current issues, find previously detected problems, and open individual issues for investigation.

Types of Issues#

OpsAI can identify different categories of problems depending on the telemetry collected and enabled integrations.

For example, OpsAI can help investigate a crashing Kubernetes pod, an application exception, or a slow database operation detected through application tracing.

Application Errors#

OpsAI detects supported application errors from APM and RUM telemetry.

It uses the available stack traces, error metadata, and related telemetry to provide context for investigation.

When repository access is configured, OpsAI can also correlate errors with relevant source code.

Kubernetes Issues#

OpsAI identifies supported issues in Kubernetes clusters monitored by the Middleware Kube Agent.

These issues can include problems affecting pods, workloads, and other Kubernetes resources.

You can investigate the affected resources and review proposed remediation steps.

Performance Issues#

OpsAI can also identify supported application performance problems, such as:

• Slow database queries
• N+1 database queries
• Consecutive database queries
• Repeated HTTP requests
• Slow API calls
• Large HTTP payloads
• Frontend asset performance issues

Performance issues appear in the issue list under the Performance type.

For example, if an application repeatedly executes the same database query, OpsAI can identify the pattern and help investigate the affected operation.

Filter Issues#

Use the filters on the OpsAI Home screen to narrow down the issue list.

You can filter issues by attributes such as:

• Issue Type — Focus on infrastructure, Kubernetes, application, or other supported issue categories.
• Status — View issues based on their current state, such as Open or Resolved.

For example, to investigate active Kubernetes problems:

1. Open OpsAI Home.
2. Filter the issue list by Kubernetes-related issues.
3. Select the Open status.
4. Review the matching issues.
5. Click an issue to inspect its details.

Grouped Issues#

OpsAI groups related issue occurrences to make recurring or connected errors easier to investigate.

For example, the same application error may occur across multiple services or hosts.

A grouped issue brings related occurrences together so you can assess the scope of a recurring problem before inspecting a specific occurrence.

Depending on the issue, the group may include occurrences across:

• Services
• Applications
• Hosts
• Kubernetes clusters

Use grouping to understand how widely an issue affects your environment and navigate to a specific occurrence.

Issue Details#

Click any issue from the list to open its Issue Details screen.

This view provides information about the detected problem and the context available for investigation.

Depending on the issue type, the details can include:

• Error or issue description
• Affected application or infrastructure resource
• Stack trace or exception details
• Related logs and telemetry
• Issue occurrences
• Relevant performance information
• Investigation and fix options

Use the issue details to understand what failed and which resource is affected before starting an OpsAI investigation.

Investigate an Issue#

Once an issue is detected:

1. Open OpsAI Home.
2. Find the issue using the list or filters.
3. Click the issue to open its details.
4. Review the error information and available context.
5. Start an OpsAI investigation.
6. Review the root cause analysis and proposed solution.

You can also ask follow-up questions if you need more information about the error.

For detailed instructions, see Fix with OpsAI.

Automatically Investigate Detected Issues#

By default, you can manually select an issue and start an investigation.

If you enable Auto Investigation, OpsAI automatically investigates supported detected issues within the configured monitoring scope.

To configure this:

1. Go to Settings → OpsAI Settings.
2. Open Auto Investigation.
3. Select the monitoring scope for Kubernetes, APM, or RUM.
4. Enable Auto-Investigate for the required sources.

You can also enable automation across all supported sources from the main OpsAI dashboard.

Once enabled, OpsAI analyzes new issues and prepares root cause analysis and suggested fixes without requiring you to start each investigation manually.

Issue Notifications#

OpsAI can notify your team about detected or investigated issues through configured notification channels.

Go to Settings → OpsAI Settings to configure notification mediums and frequency.

Supported options include:

• Email
• Slack
• Microsoft Teams
• Webhook

You can configure immediate notifications or a notification interval to consolidate multiple issues.

When Slack is configured, automatic investigation results can also be shared in the relevant alert thread.

Next Steps#

Once an issue is detected, use Fix with OpsAI to investigate its root cause, generate a solution, or prepare a code fix.