Types of operations in performance recommendations
This page lists the operation types seen in Jira performance recommendations.
What is an operation type?
When an app appears in a recommendation, the operation type specifies what it was doing at that time, for example, contacting the database, calling another service, or searching.
During certain events, such as when Marketplace apps have long-waiting, long-running, or blocked threads, you can download a CSV file to better understand the issue. This CSV file will show the Marketplace app’s operation type.
If the activity isn't yet recognized, the operation type appears as a dash (-). This doesn’t mean nothing was happening. It simply means the operation type hasn’t been classified.
Operation types
This table lists all the operation types we currently recognize and their meanings.
Operation type | Description |
|---|---|
Database query | The thread is actively running a database query rather than waiting for a connection. A high database query count typically points to slow or inefficient queries, missing indexes, or an overloaded database. |
Database connection pool | The thread is waiting to acquire a pooled database connection. It can indicate that the threads are not executing database query, but instead are queuing for an available connection slot. A high count typically indicates connection-pool exhaustion or slow queries holding connections too long. |
Outbound HTTP call | The thread is making an outbound HTTP call and waiting for the response (for example, to an external API, an Atlassian service, or any HTTP-based integration). A high count typically indicates a slow or unresponsive external service, or network latency between the instance and that service. |
Directory service (LDAP) | The thread is performing directory service operations (such as Lightweight Directory Access Protocol (LDAP) or Crowd directory lookups). These operations are common in Jira deployments that use external LDAP or Active Directory for user authentication and group resolution. A high count typically indicates points to a slow or overloaded directory server, or expensive user and group lookups. |
Search index (Lucene) | The thread is performing Lucene-based index read or write operations (such as Jira search or re-indexing). This covers both query-time search and background re-indexing. A high count typically indicates index lock contention, an in-progress re-index, or an unexpectedly large search workload. |
Waiting for lock | The thread is waiting to acquire a lock on a shared resource that another thread is currently holding. This happens when many threads need the same resource at once, or when a lock is held for too long. A high count typically points to a heavily contended shared resource or a slow-to-release lock. In some cases, this contention can result in a deadlock (where threads block each other in a cycle). |
Disk I/O | File or disk input or output. Includes attachment storage, log writing, and any other file-backed operation that stalls the thread. A high count typically indicates high disk latency or shared storage, or an unusually heavy file-processing workload. |
Scheduled task | Quartz scheduler, timer, or delayed-task execution. This indicates that the thread is running a background scheduled task rather than handling a user request. A high count typically points to long-running or overlapping scheduled jobs competing with user-facing work. |
Was this helpful?