Flutter SDK

# pubspec.yaml
dependencies:
  abrova_trace_flutter_sdk:
    hosted: https://center.abrova.ir/api/packages/abrova/pub
    version: ^0.2.5

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url "https://center.abrova.ir/api/packages/abrova/maven" }
    }
}

pod 'AbrovaTrace', :git => 'https://github.com/Abrova-co/abrova-trace-ios-sdk.git', :tag => '0.2.4'

flutter pub get

import 'package:flutter/material.dart';
import 'package:abrova_trace_flutter_sdk/abrova_trace_flutter_sdk.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // Initialize AbrovaTrace
  await AbrovaTrace.init(AbrovaTraceConfig(
    apiKey: 'ab_live_your_api_key',
    environment: 'production',
    release: '1.0.0',
  ));

  runApp(MyApp());
}

import 'package:flutter/material.dart';
import 'package:abrova_trace_flutter_sdk/abrova_trace_flutter_sdk.dart';

void main() async {
  // IMPORTANT: Initialize AbrovaTrace FIRST, before WidgetsFlutterBinding
  await AbrovaTrace.initWithZone(
    AbrovaTraceConfig(
      apiKey: 'ab_live_your_api_key',
      environment: 'production',
      release: '1.0.0',
      captureUncaughtErrors: true,
    ),
    () async {
      // Move all initialization inside this callback
      WidgetsFlutterBinding.ensureInitialized();

      // Any other async initialization goes here
      // await Firebase.initializeApp();
      // await setupDatabase();

      runApp(MyApp());
    },
  );
}

try {
  riskyOperation();
} catch (e, stackTrace) {
  await AbrovaTrace.captureException(
    e,
    stackTrace: stackTrace,
    message: 'Failed to perform risky operation',
    extra: {'user_id': 'user123'},
  );
}

await AbrovaTrace.captureMessage(
  'User completed onboarding',
  extra: {'step': 'welcome_screen'},
);

// With a level and tags
await AbrovaTrace.captureMessage(
  'API rate limit approaching',
  level: MessageLevel.warning,
  tags: {'feature': 'sync'},
);

await AbrovaTrace.captureException(
  exception,
  extra: {
    'user_id': 'user123',
    'feature': 'shopping_cart',
    'action': 'checkout',
    'cart_items': 5,
    'total_amount': 99.99,
  },
);

// Set after user login
AbrovaTrace.setUserId('user_123');

// Get current user ID
final userId = AbrovaTrace.getUserId();

// Set individual extra
AbrovaTrace.setExtra('subscription', 'premium');

// Set multiple extras at once
AbrovaTrace.setExtras({
  'subscription': 'premium',
  'feature_flags': 'dark_mode,beta',
});

// Read extra data
final sub = AbrovaTrace.getExtra('subscription');
final allExtras = AbrovaTrace.getExtras();

// Clear all extras
AbrovaTrace.clearExtras();

// Set individual tag
AbrovaTrace.setTag('team', 'checkout');

// Set multiple tags at once
AbrovaTrace.setTags({
  'team': 'checkout',
  'module': 'payments',
});

// Read tags
final team = AbrovaTrace.getTag('team');
final allTags = AbrovaTrace.getTags();

// Clear all tags
AbrovaTrace.clearTags();

import 'package:abrova_trace_flutter_sdk/abrova_trace_flutter_sdk.dart';

// User action breadcrumb
AbrovaTrace.addUserBreadcrumb('Added item to cart', data: {
  'product_id': 'abc',
  'quantity': 2,
});

// Navigation breadcrumb
AbrovaTrace.addNavigationBreadcrumb('HomeScreen', 'ProductDetail');

// HTTP request breadcrumb
AbrovaTrace.addHttpBreadcrumb('POST', 'https://api.example.com/orders', statusCode: 201);

// Generic breadcrumb
AbrovaTrace.addBreadcrumb(
  'Order placed',
  type: BreadcrumbType.info,
  data: {'order_id': '12345', 'total': 99.99},
);

// Clear all breadcrumbs
AbrovaTrace.clearBreadcrumbs();

await AbrovaTrace.initWithZone(
  AbrovaTraceConfig(apiKey: 'ab_live_...'),
  () async {
    WidgetsFlutterBinding.ensureInitialized();

    // Enable automatic tap breadcrumbs
    AbrovaTrace.enableGestureBreadcrumbs();

    runApp(MyApp());
  },
);

{
  "message": "Tap on ElevatedButton: \"Pay\"",
  "type": "user",
  "timestamp": "2026-05-15T14:32:18.421Z",
  "data": {
    "action": "tap",
    "widget": "ElevatedButton",
    "label": "Pay",
    "key": "checkout-pay-button",
    "path": "CheckoutPage > Scaffold",
    "route": "/checkout",
    "position": { "x": 187, "y": 614 }
  }
}

IconButton(
  key: const ValueKey('cart-remove-row-2'),  // ← surfaces in breadcrumb
  icon: const Icon(Icons.delete),
  onPressed: _removeItem,
)

AbrovaTrace.disableGestureBreadcrumbs();

// Enable logging after AbrovaTrace.init()
AbrovaTrace.enableLogging(sourceId: 'my-flutter-app');

AbrovaTrace.info('User login successful', metadata: {'user_id': 'user_123'});

// Create an HTTP client that automatically tracks all requests
final client = AbrovaTrace.createPerformanceClient();

final response = await client.get(Uri.parse('https://api.example.com/users'));
// Duration, status code, and errors are automatically reported

import 'package:http/http.dart' as http;
import 'package:abrova_trace_flutter_sdk/abrova_trace_flutter_sdk.dart';

final client = PerformanceHttpClient(
  apiKey: 'ab_live_...',              // Required
  environment: 'production',
  releaseVersion: '1.0.0',
  inner: http.Client(),                // Default: a new http.Client()
  addBreadcrumbs: true,                // Also add HTTP breadcrumbs (default: true)
  excludedHosts: {'analytics.example.com'}, // Hosts to skip
  minDurationMs: 50,                   // Skip requests faster than this (default: 0)
);

final response = await client.get(Uri.parse('https://api.example.com/users'));

// Or wrap an existing client
final tracked = http.Client().withPerformanceTracking(apiKey: 'ab_live_...');

// Send buffered spans now, and stop the client when done
await client.flush();
client.close();

final result = await AbrovaTrace.trackOperation(
  'load_user_profile',
  () async {
    final user = await fetchUser();
    await cacheUser(user);
    return user;
  },
  operationType: 'custom',
);

final start = DateTime.now();

// Report a single performance span
await AbrovaTrace.reportPerformanceSpan(
  PerformanceSpan.fromHttpRequest(
    method: 'GET',
    url: 'https://api.example.com/products',
    statusCode: 200,
    startTime: start,
    durationMs: 245,
  ),
);

// Report a batch of spans
await AbrovaTrace.reportPerformanceSpanBatch([
  PerformanceSpan.fromHttpRequest(
    method: 'GET',
    url: '/api/users',
    statusCode: 200,
    startTime: start,
    durationMs: 150,
  ),
  PerformanceSpan.custom(
    operation: 'image_processing',
    startTime: start,
    durationMs: 800,
  ),
]);

void main() async {
  await AbrovaTrace.init(AbrovaTraceConfig(
    apiKey: 'ab_live_your_api_key',
    environment: 'production',
    debug: false, // Disable in production extensions
  ));

  runApp(MyExtensionApp());
}

void main() async {
  // Required before init() on Android and iOS
  WidgetsFlutterBinding.ensureInitialized();

  await AbrovaTrace.init(AbrovaTraceConfig(
    apiKey: 'ab_live_your_api_key',
    environment: 'production',
    captureUncaughtErrors: true, // Recommended for mobile
  ));

  runApp(MyMobileApp());
}

void main() async {
  await AbrovaTrace.init(AbrovaTraceConfig(
    apiKey: 'ab_live_your_api_key',
    environment: 'production',
    debug: kDebugMode, // Enable debug in development
  ));

  runApp(MyWebApp());
}

AbrovaTraceConfig(
  apiKey: 'ab_live_your_api_key',          // Required
  environment: 'production',             // Default: 'production'
  release: '1.0.0',                      // Optional
  captureUncaughtErrors: true,           // Default: true
  enabled: true,                         // Default: true
  debug: false,                          // Default: false
  timeout: 30,                           // Default: 30 seconds
  sampleRate: 1.0,                       // 0.0 to 1.0
  maxBreadcrumbs: 20,                    // Default: 20
  enableOfflineStorage: true,            // Default: true
  collectDeviceInfo: true,               // Default: true
  logHandler: (level, message, error, stackTrace) {}, // Optional
)

import 'package:flutter/material.dart';
import 'package:abrova_trace_flutter_sdk/abrova_trace_flutter_sdk.dart';

void main() async {
  await AbrovaTrace.initWithZone(
    AbrovaTraceConfig(
      apiKey: 'ab_live_your_api_key',
      environment: const String.fromEnvironment('ENV', defaultValue: 'development'),
      release: '1.0.0',
      captureUncaughtErrors: true,
      sampleRate: 1.0,
      maxBreadcrumbs: 20,
      enableOfflineStorage: true,
      debug: true,
    ),
    () async {
      WidgetsFlutterBinding.ensureInitialized();

      // Auto-capture taps as breadcrumbs (all platforms)
      AbrovaTrace.enableGestureBreadcrumbs();

      // Enable logging
      AbrovaTrace.enableLogging(
        sourceId: 'my-flutter-app',
        sourceName: 'My Flutter App',
      );

      runApp(MyApp());
    },
  );
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  const HomeScreen({super.key});

  @override
  State<HomeScreen> createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  @override
  void initState() {
    super.initState();
    AbrovaTrace.setUserId('user_123');
    AbrovaTrace.setTag('screen', 'HomeScreen');
    AbrovaTrace.addNavigationBreadcrumb('Launch', 'HomeScreen');
  }

  Future<void> _handlePurchase() async {
    AbrovaTrace.addUserBreadcrumb('Initiated purchase', data: {'product': 'Premium'});

    try {
      await AbrovaTrace.trackOperation('process_purchase', () async {
        await processPurchase();
      });
      AbrovaTrace.info('Purchase successful', metadata: {'amount': 99.99});
    } catch (e, stackTrace) {
      await AbrovaTrace.captureException(
        e,
        stackTrace: stackTrace,
        message: 'Purchase failed',
        extra: {'user_id': 'user_123', 'screen': 'HomeScreen'},
      );
    }
  }

  Future<void> processPurchase() async {
    // ... purchase logic
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('My App')),
      body: Center(
        child: ElevatedButton(
          onPressed: _handlePurchase,
          child: const Text('Purchase'),
        ),
      ),
    );
  }
}