Copy as Markdown[Open in ChatGPT](https://chatgpt.com/?q=Read%20https%3A%2F%2Fcoralogix.com%2Fdocs%2Fuser-guides%2Fapm-v2%2Ffeatures%2Ftransactions.md%20and%20help%20me%20with%20my%20question%20about%20this%20Coralogix%20documentation%20page.)[Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fcoralogix.com%2Fdocs%2Fuser-guides%2Fapm-v2%2Ffeatures%2Ftransactions.md%20and%20help%20me%20with%20my%20question%20about%20this%20Coralogix%20documentation%20page.)

# Monitor transactions

The **Transactions** tab breaks a service down into its individual transactions - the requests it serves, each identified by its entry-point operation - so you can find the slowest, busiest, or most error-prone and drill into the segments and spans behind them. A transaction is what enters the service, so the tab covers incoming requests, split by **trigger**: **Web** (HTTP requests) and **Pub-Sub** (messaging consumers).

Use it to:

* **Pinpoint the slowest transaction**: find the transaction with the highest duration or error rate, and fix the request path that hurts users most.
* **See where a transaction spends its time**: break it into segments - a database call, an external API, or internal logic - and find the one that contributes the most latency or errors.
* **Separate web from messaging traffic**: scope the tab by trigger to compare HTTP endpoints against messaging consumers.
* **Move from an aggregate to the evidence**: jump from an aggregated transaction or segment straight to the exact spans and traces behind it.

[![The Transactions tab: the trigger toggle (All / Web / Pub-Sub), the Requests, Errors, and Duration charts, and the transactions table.](/docs/assets/images/transactions-tab-20dd7b8ea8cca31017795dd1c6be81d3.webp)](https://coralogix.com/docs/assets/images/transactions-tab-20dd7b8ea8cca31017795dd1c6be81d3.webp)

## What you need[​](#what-you-need "Direct link to What you need")

* Coralogix [Application Performance Monitoring (APM)](https://coralogix.com/docs/user-guides/apm-v2/getting-started/apm-onboarding-tutorial.md) installed and configured.
* [Span Metrics](https://coralogix.com/docs/user-guides/apm-v2/getting-started/span-metrics.md) enabled for the service.
* To break a transaction down into segments in its drilldown, the service must emit transaction data. This requires the Coralogix transactions processor: see [Enable the transactions processor](https://coralogix.com/docs/user-guides/apm-v2/features/transactions/enable-transactions-processor.md).

## Key concepts[​](#key-concepts "Direct link to Key concepts")

A user visits an e-commerce website and clicks on a product to view its details. This action initiates a transaction. The transaction begins when the user's request reaches a service and ends when the service sends back the product details as a response. During this transaction, several operations occur: the service might query a database to retrieve the product information, call external services for current pricing, and execute internal logic to prepare the content for display. Each of these operations represents a segment. The transaction breakdown shows how these segments collectively contribute to the request's overall response time and performance.

Transaction

A **transaction** denotes a singular logical unit of work in a software application. More precisely, it encompasses the function and method calls constituting that unit of work. Each transaction consists of a root span, an operation that serves as its entry point and triggers all other related operations.

Operation

Every transaction may contain hundreds, if not thousands, of spans, grouped per operation name. An **operation** is a logical entity consolidating all spans with the same action type.

Segment

A **segment** is an operation within a transaction that influences the overall performance of that transaction. Examples include external service calls and database calls. Each segment provides insights into its performance and how it affects the transaction over time.

Coralogix's APM captures and monitors the performance metrics associated with each segment that makes up the transaction. This information helps identify bottlenecks, optimize code, and ensure a smooth and efficient user experience during the entire purchase process.

Root transaction

A **root transaction** is the entry-point service operation that initiates subsequent actions within the service - such as database queries, internal operations, external API calls, or downstream service requests. It is the main request or operation that triggers a chain of dependent actions.

## Transactions vs. spans[​](#transactions-vs-spans "Direct link to Transactions vs. spans")

Transactions and the [Explore spans](https://coralogix.com/docs/user-guides/data_exploration/spans.md) feature serve different analysis contexts and depths. Transactions examine the entire sequence of events over time within a service. This method explains how different parts of the transaction interact and evolve, providing deep insights into the internal dynamics of service requests.

While Explore spans captures snapshots of individual operations at specific moments, it does not effectively identify long-term bottlenecks within the overall flow. Transactions deliver a detailed analysis that helps pinpoint the underlying causes of performance issues across the entire flow of the service.

In essence, transactions complement span analysis by examining the collective impact of operations within a service, offering a more comprehensive view of their influence on performance over time.

## Access the Transactions tab[​](#access-the-transactions-tab "Direct link to Access the Transactions tab")

1. In your Coralogix toolbar, select **APM**.
2. Select a service to open its drilldown, then select the **Transactions** tab.
3. Use the **Trigger** toggle to scope the tab to **All**, **Web**, or **Pub-Sub** traffic, and the **Top N** selector to set how many transactions to return (**Top 5**, **Top 20** by default, or **Top 100**).

The trigger and Top N selections apply to both the summary charts and the transactions table. The environment filter and any drilldown dimensions scope the transactions shown.

The **Transactions** tab is available for services. Databases expose an **Operations** tab instead.

## Trigger[​](#trigger "Direct link to Trigger")

A transaction is a request that enters the service, so every transaction has a **trigger** that reflects how its entry point was invoked:

* **Web**: HTTP requests, taken from server spans.
* **Pub-Sub**: messaging consumers, taken from consumer spans.

Select **All** to view both. Trigger is also available as a column in the transactions table.

## Summary charts[​](#summary-charts "Direct link to Summary charts")

Three charts at the top of the tab summarize the selected traffic, each plotting the top transactions:

* **Requests**: request throughput per transaction, plotted per second.
* **Errors**: the share of requests that failed, per transaction.
* **Duration**: response time per transaction, with a percentile selector (**Avg**, **P50**, **P75**, **P90**, **P95**, **P99**) that opens on **Avg**.

Every chart is split **by transaction**; add a second dimension - **None**, **Environment**, **Version**, or **Status code** - to break each transaction's series down further. Use each chart's menu to change its chart type and scale, open it in **Full view**, open **View query**, or open the chart in the Metric Explorer.

## Transactions table[​](#transactions-table "Direct link to Transactions table")

The **Transactions** table below the charts lists every transaction matching the selected trigger. By default it shows:

* **Name**: the transaction (endpoint or operation) name.
* **Trigger**: how the entry point was invoked: Web or Pub-Sub.
* **Requests**: total requests over the selected timeframe.
* **Requests trend**: a sparkline of requests per second over the range.
* **Errors**: total failed requests.
* **Error rate trend**: a sparkline of the error rate over the range.
* **Error%**: error rate as a share of total requests.
* **Avg latency trend**: a sparkline of average response time over the range.
* **P95**: 95th-percentile response time.
* **Total Time Spent**: the transaction's cumulative processing time and its share of the transactions shown.

The table returns the Top N transactions ranked by **Total Time Spent**. Selecting a column header re-sorts the returned rows in place; it does not change which transactions are returned. Select **Manage columns** to add other columns - including **Apdex impact**, **Method**, **Requests/s**, **Errors/s**, **Avg**, and other latency percentiles (**P50**, **P75**, **P90**, **P99**). Use **Search transactions** to find one by name, **Export** to download the table, and the comparison control to compare each transaction's metrics against an earlier period.

Each row has an actions menu (the icon) with **View transaction** (open its drilldown), **View traces** (open the transaction's traces), **Add to filter** (scope the tab to that transaction), and **Copy transaction name**. The same actions menu is available from a transaction's series in the summary charts above.

## Investigate a transaction[​](#investigate-a-transaction "Direct link to Investigate a transaction")

Select a transaction row - or its series in the summary charts above - to open its drilldown drawer, which summarizes the transaction over the selected timeframe. The header shows the service and transaction name, and a row of key metrics - **Requests**, **P95**, **Error rate**, and **Total time spent**. From the header you can **Copy transaction name** or **Copy link** (a deep link back to the open drawer), change the drawer's range with the **time picker**, and step through the table with **Previous transaction** / **Next transaction** without closing the drawer. The open transaction's row stays highlighted in the table behind it.

[![The transaction drilldown drawer: the Requests, P95, Error rate, and Total time spent metrics, the Requests, Errors, and Duration charts grouped by segment, the Segment breakdown table, and the spans list.](/docs/assets/images/transaction-drilldown-ad1dc67276410dad5ec6fc3868238ebf.webp)](https://coralogix.com/docs/assets/images/transaction-drilldown-ad1dc67276410dad5ec6fc3868238ebf.webp)

The drawer contains:

* **Charts**: **Requests**, **Errors**, and **Duration** over time for this transaction. Group them by **None**, **Segment**, **Environment**, or **Version**: the **Segment** grouping fans the transaction out into the segments that make it up.
* **Segment breakdown**: for services that emit transaction data, a table of the segments that run as part of the transaction. See [Segment breakdown](#segment-breakdown).
* **Spans**: the most recent spans of the transaction's segments. See [Spans](#spans).

### Segment breakdown[​](#segment-breakdown "Direct link to Segment breakdown")

For services that emit transaction data, the drawer shows a **Segment breakdown** table between the charts and the spans list. It breaks the transaction into the **segments** that run as part of it - the downstream calls and internal steps that make up its work - so you can see where the transaction spends its time before you reach the raw spans. A transaction with no further breakdown shows only its spans.

Note

The segment breakdown requires the Coralogix transactions processor. See [Enable the transactions processor](https://coralogix.com/docs/user-guides/apm-v2/features/transactions/enable-transactions-processor.md).

The Segment breakdown table lists each segment with:

* **Name**: the operation this segment represents. The transaction's own root segment heads the table, tagged **Root Transaction**, followed by the segments it contains.
* **Method**: request method, where applicable.
* **Calls**: total calls to this segment in the selected time range.
* **Avg calls/flow**: average calls to this segment per transaction.
* **Error rate**: share of this segment's calls that failed.
* **Time spent**: total time spent in this segment across all calls.
* **P95**: 95th-percentile duration of a single call.
* **Avg time**: average duration of a single call.
* **Flow time %**: share of the transaction's total time spent in this segment.

Use **Search segments** to narrow the list, select a segment row to add it to the spans filter below, or sort by any column to surface slow or error-prone segments.

### Spans[​](#spans "Direct link to Spans")

The **Spans** section lists the most recent spans of this transaction's segments, scoped to the transaction you drilled into. Each span shows its timestamp, operation, span kind, resource, duration, and status. Use **Search spans** to filter the list, **Filter by segment** to scope it to one segment, and **Open in Explore** to open the spans in [Explore](https://coralogix.com/docs/user-guides/data_exploration/spans.md).

Select a span to open the **Tracing drilldown**, where you can switch between Dependencies, Flame, and Gantt views and pivot to correlated logs, infrastructure, profiles, or AI insights. See [Investigate with the tracing drilldown](https://coralogix.com/docs/user-guides/data_exploration/spans/span-drilldown.md) for the full reference.

## Next steps[​](#next-steps "Direct link to Next steps")

To break transactions into segments, enable the [Coralogix transactions processor](https://coralogix.com/docs/user-guides/apm-v2/features/transactions/enable-transactions-processor.md).

## Additional resources[​](#additional-resources "Direct link to Additional resources")

* [Introduction to Application Performance Monitoring](https://coralogix.com/docs/user-guides/apm-v2/getting-started/apm-onboarding-tutorial.md)
* [Enable the transactions processor](https://coralogix.com/docs/user-guides/apm-v2/features/transactions/enable-transactions-processor.md)
* [Explore spans](https://coralogix.com/docs/user-guides/data_exploration/spans.md)