APM Overview — Abrova Trace

Real-time performance monitoring across all your applications with HTTP latency, database queries, custom operations, p50/p95/p99 percentiles, and Core Web Vitals.

AbrovaTrace APM provides real-time performance monitoring across all your applications. Track HTTP request latency, database queries, and custom operations with p50/p95/p99 percentile metrics. For web apps, monitor Core Web Vitals (LCP, INP, CLS, plus TTFB and FCP).

API Latency Tracking

Monitor HTTP request/response times with p50, p95, p99 percentiles

Core Web Vitals

LCP, INP, CLS, TTFB and FCP metrics for web platforms

Custom Operations

Track any async operation with automatic duration measurement

Percentile Analysis

p50, p95, p99 latency metrics for accurate insights

Batch Reporting

Efficient batched span uploads to minimize network overhead

Multi-Platform

Works across Next.js, Flutter, Android, iOS, Node.js, and Laravel

Included.

APM is included in Abrova Trace at no extra cost. Spans and Web Vitals are not counted as new issues, so they do not use your free monthly allowance or your wallet.

Data Retention#

Spans and Web Vitals are kept for your project's data retention period: 7 days free, or 30 days for +50,000 Toman per project a month from your wallet — see Pricing.

Performance Span Structure#

Each tracked operation creates a Performance Span with the following fields:

typescript

interface PerformanceSpan {
  operation: string;        // e.g., "GET /api/users"
  operationType: 'http' | 'db' | 'custom';
  httpMethod?: string;      // GET, POST, PUT, DELETE
  httpUrl?: string;         // Full request URL
  httpStatusCode?: number;  // 200, 404, 500, etc.
  httpHost?: string;        // api.example.com
  durationMs: number;       // Request duration
  startTime: string;        // ISO timestamp
  endTime?: string;         // ISO timestamp
  traceId?: string;         // Distributed trace ID
  spanId?: string;          // Unique span ID
  parentSpanId?: string;    // Parent span for nesting
  platform: string;         // nextjs, flutter, web, android, ios, nodejs, laravel
  environment?: string;     // production, staging, dev
  releaseVersion?: string;  // App version
  tags?: Record<string, string>;  // Custom tags
  metadata?: Record<string, any>; // Additional data
  status: 'ok' | 'error';
  errorMessage?: string;
}

Quick Start by SDK#

Next.js / React

typescript

import { AbrovaTrace } from '@abrova-trace/nextjs-sdk';

AbrovaTrace.init({
  apiKey: 'ab_live_your_api_key',
  environment: 'production',
});

// Enable automatic HTTP tracking (intercepts fetch)
AbrovaTrace.getInstance()?.enablePerformanceTracking();

// Enable Web Vitals (LCP, INP, CLS, TTFB, FCP)
AbrovaTrace.getInstance()?.enableWebVitals();

Flutter

dart

import 'package:abrova_trace_flutter_sdk/abrova_trace_flutter_sdk.dart';

// Create a performance-tracking HTTP client
final client = PerformanceHttpClient(
  apiKey: 'ab_live_your_api_key',
  environment: 'production',
);

// All requests are automatically tracked
final response = await client.get(
  Uri.parse('https://api.example.com/users'),
);

Android (Kotlin)

kotlin

import ir.abrova.trace.sdk.network.AbrovaTracePerformanceInterceptor
import okhttp3.OkHttpClient

val client = OkHttpClient.Builder()
    .addInterceptor(AbrovaTracePerformanceInterceptor())
    .build()

// All requests through this client are automatically tracked

iOS (Swift)

swift

import AbrovaTrace

// Enable automatic URLSession tracking
AbrovaTrace.shared.enablePerformanceTracking()

// Or use a custom session with tracking
let config = AbrovaTrace.shared.performanceSessionConfiguration()
let session = URLSession(configuration: config)

Node.js

javascript

const AbrovaTrace = require('@abrova-trace/nodejs-sdk');

// Time any async operation and report it as a span
const users = await AbrovaTrace.trackOperation(
  'fetch-users',
  () => db.query('SELECT * FROM users'),
  { operationType: 'db' }
);

Viewing Data in Dashboard#

Once tracking is enabled, open Trace → Performance in Abrova Console to see:

Overview Stats — Requests, error rate, p50, p95 and p99 latency
Latency — p50, p95, p99 over time, plus requests over time with errors stacked
Operations — Each operation with its type, request count, latency percentiles and errors
Status codes, Web Vitals and Failed requests cards
Filtering — Time range (1h, 24h, 7d, 30d or custom), platform, environment, release

API Endpoints#

SDKs report spans to these endpoints:

Endpoint	Method	Description
/api/performance/spans	POST	Report single span
/api/performance/spans/batch	POST	Report batch (max 50)
/api/performance/web-vitals	POST	Report Web Vitals data

Best Practices#

Use Meaningful Operation Names

Use descriptive names like "GET /api/users" instead of generic names for easier identification

Add Custom Tags

Add tags like user ID, tenant ID, or feature flags to filter and segment data

Set Environment Correctly

Always set environment (production, staging, development) to separate data

Monitor p95/p99 Not Just Average

Average latency hides outliers — focus on p95 and p99 for worst-case experience

Use Batch Reporting

SDKs batch spans by default — avoid reporting individual spans when possible

Exclude Health Check Endpoints

Filter out noisy endpoints like /health or /ping from tracking