PHPackages                             ameax/apilogger - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Logging & Monitoring](/categories/logging)
4. /
5. ameax/apilogger

ActiveLibrary[Logging & Monitoring](/categories/logging)

ameax/apilogger
===============

Powerful API request/response logging package for Laravel with multiple storage backends, privacy-first data sanitization, and performance optimization

1253↓33.3%[4 PRs](https://github.com/ameax/apilogger/pulls)PHPCI passing

Since Oct 13Pushed 2mo agoCompare

[ Source](https://github.com/ameax/apilogger)[ Packagist](https://packagist.org/packages/ameax/apilogger)[ RSS](/packages/ameax-apilogger/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependenciesVersions (5)Used By (0)

API Logger for Laravel
======================

[](#api-logger-for-laravel)

[![Latest Version on Packagist](https://camo.githubusercontent.com/75ffd7c534c72813363cd62e713fa254b47e2395e95da1169c745668f673fd30/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f616d6561782f6170696c6f676765722e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/ameax/apilogger)[![GitHub Tests Action Status](https://camo.githubusercontent.com/51bbd99450ccb2283878d0a10b208a3b6165380e5026d48db0b3ccce06565efe/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f616d6561782f6170696c6f676765722f72756e2d74657374732e796d6c3f6272616e63683d6d61696e266c6162656c3d7465737473267374796c653d666c61742d737175617265)](https://github.com/ameax/apilogger/actions?query=workflow%3Arun-tests+branch%3Amain)[![GitHub Code Style Action Status](https://camo.githubusercontent.com/87532e815d4b1419d1f1ba305ff0229de2119bc63799ec9561f97d92fd6b657a/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f616d6561782f6170696c6f676765722f6669782d7068702d636f64652d7374796c652d6973737565732e796d6c3f6272616e63683d6d61696e266c6162656c3d636f64652532307374796c65267374796c653d666c61742d737175617265)](https://github.com/ameax/apilogger/actions?query=workflow%3A%22Fix+PHP+code+style+issues%22+branch%3Amain)[![Total Downloads](https://camo.githubusercontent.com/4940cca146fee3af5268601a07b6ed944ea6ee8930bb0ff23527c5a65f3b1e08/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f616d6561782f6170696c6f676765722e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/ameax/apilogger)

A powerful, flexible, and performant API request/response logging package for Laravel applications. Track API usage, debug issues, monitor performance, and maintain compliance with ease.

Features
--------

[](#features)

- 🚀 **Multiple Storage Backends**: Database, JSON Lines, or custom drivers
- 🔒 **Privacy-First**: Automatic sanitization of sensitive data
- ⚡ **High Performance**: Queue support, batch operations, circuit breaker pattern
- 🎯 **Smart Filtering**: Log only what matters with flexible filters
- 📊 **Rich Insights**: Track response times, error rates, usage patterns
- 🧹 **Auto-Cleanup**: Configurable retention policies with different durations for errors
- 🔄 **Fallback Support**: Multiple storage drivers with automatic failover
- 🎨 **Highly Configurable**: Extensive configuration options for every use case
- 🔗 **Outbound API Logging**: Track external API calls with Guzzle and PSR-18 clients
- 🔍 **Correlation IDs**: Link related requests across inbound and outbound calls
- 🏢 **Service Registry**: Manage and configure multiple external services
- 📤 **HAR & HTML Export**: Export logs in industry-standard HAR format or standalone HTML
- 🌐 **PSR-18 Support**: Log any PSR-18 compliant HTTP client (Typesense, HTTPlug, etc.)

Requirements
------------

[](#requirements)

- PHP 8.2 or higher
- Laravel 11.x or 12.x

Installation
------------

[](#installation)

Install the package via Composer:

```
composer require ameax/apilogger
```

### Database Setup

[](#database-setup)

If using database storage (default), publish and run the migrations:

```
php artisan vendor:publish --tag="apilogger-migrations"
php artisan migrate
```

### Configuration

[](#configuration)

Publish the configuration file:

```
php artisan vendor:publish --tag="apilogger-config"
```

This will create `config/apilogger.php` with extensive configuration options.

Quick Start
-----------

[](#quick-start)

### Basic Usage

[](#basic-usage)

The package automatically logs API requests once installed. Add the middleware to your API routes:

```
// In routes/api.php or your route service provider
Route::middleware(['api', \Ameax\ApiLogger\Middleware\LogApiRequests::class])
    ->group(function () {
        // Your API routes
    });
```

Or add it globally in your HTTP Kernel:

```
// In app/Http/Kernel.php
protected $middlewareGroups = [
    'api' => [
        // Other middleware...
        \Ameax\ApiLogger\Middleware\LogApiRequests::class,
    ],
];
```

### Configuration Options

[](#configuration-options)

```
// config/apilogger.php
return [
    'enabled' => env('API_LOGGER_ENABLED', true),

    // Logging level: none, basic, detailed, full
    'level' => env('API_LOGGER_LEVEL', 'detailed'),

    // Storage configuration
    'storage' => [
        'driver' => env('API_LOGGER_DRIVER', 'database'),

        // Database storage options
        'database' => [
            'connection' => null, // Uses default connection
            'table' => 'api_logs',
        ],

        // JSON Lines storage options
        'jsonline' => [
            'path' => storage_path('logs/api'),
            'daily_rotation' => true,
            'compress_old_files' => true,
        ],
    ],

    // Privacy settings
    'privacy' => [
        'exclude_fields' => ['password', 'token', 'secret'],
        'exclude_headers' => ['Authorization', 'Cookie'],
        'masking_strategy' => 'partial', // full, partial, or hash
    ],

    // Performance settings
    'performance' => [
        'use_queue' => false,
        'queue_name' => 'default',
        'batch_size' => 100,
        'timeout' => 1000, // milliseconds
    ],

    // Filter settings
    'filters' => [
        'min_response_time' => 0, // Log all requests
        'exclude_routes' => ['/health', '/metrics'],
        'exclude_methods' => ['OPTIONS'],
        'exclude_status_codes' => [],
        'always_log_errors' => true,
    ],

    // Retention settings
    'retention' => [
        'days' => 30, // Keep normal logs for 30 days
        'error_days' => 90, // Keep error logs for 90 days
    ],
];
```

Usage Examples
--------------

[](#usage-examples)

### Accessing Logs

[](#accessing-logs)

```
use Ameax\ApiLogger\Models\ApiLog;

// Get recent API logs
$logs = ApiLog::latest()->take(100)->get();

// Find logs for a specific user
$userLogs = ApiLog::forUser('user-123')->get();

// Get error logs
$errors = ApiLog::errors()->get();

// Get slow requests
$slowRequests = ApiLog::slowRequests(1000)->get(); // > 1 second

// Get logs for specific endpoint
$endpointLogs = ApiLog::forEndpoint('/api/users')->get();

// Get logs within date range
$logs = ApiLog::betweenDates('2024-01-01', '2024-01-31')->get();
```

### Using Different Storage Drivers

[](#using-different-storage-drivers)

#### Database Storage (Default)

[](#database-storage-default)

```
// config/apilogger.php
'storage' => [
    'driver' => 'database',
    'database' => [
        'connection' => null, // Uses default
        'table' => 'api_logs',
    ],
],
```

#### JSON Lines Storage

[](#json-lines-storage)

```
// config/apilogger.php
'storage' => [
    'driver' => 'jsonline',
    'jsonline' => [
        'path' => storage_path('logs/api'),
        'daily_rotation' => true,
    ],
],
```

#### Fallback Storage (Multiple Drivers)

[](#fallback-storage-multiple-drivers)

```
// config/apilogger.php
'storage' => [
    'driver' => 'fallback',
    'fallback' => [
        'drivers' => ['database', 'jsonline'],
    ],
],
```

### Custom Filtering

[](#custom-filtering)

```
use Ameax\ApiLogger\Facades\ApiLogger;

// Add custom filter in a service provider
ApiLogger::filter(function ($request, $response, $responseTime) {
    // Log only if custom condition is met
    return $request->user()->isAdmin();
});
```

### Queue Support

[](#queue-support)

Enable queue processing for better performance:

```
// config/apilogger.php
'performance' => [
    'use_queue' => true,
    'queue_name' => 'api-logs',
],
```

Don't forget to run your queue workers:

```
php artisan queue:work --queue=api-logs
```

### Data Sanitization

[](#data-sanitization)

Customize sensitive field handling:

```
use Ameax\ApiLogger\Services\DataSanitizer;

// In a service provider
$sanitizer = app(DataSanitizer::class);

// Add custom fields to exclude
$sanitizer->addExcludeFields(['credit_card', 'ssn']);

// Add custom headers to exclude
$sanitizer->addExcludeHeaders(['X-API-Key', 'X-Secret']);

// Add fields to mask (partial display)
$sanitizer->addMaskFields(['email', 'phone']);
```

### Outbound API Logging

[](#outbound-api-logging)

Track external API calls made by your application using Guzzle:

```
use Ameax\ApiLogger\Outbound\GuzzleHandlerStackFactory;
use Ameax\ApiLogger\Outbound\ServiceRegistry;
use GuzzleHttp\Client;

// Register a service for automatic logging
ServiceRegistry::register('App\Services\StripeService', [
    'enabled' => true,
    'name' => 'Stripe API',
    'log_level' => 'full',
    'hosts' => ['api.stripe.com'],
    'always_log_errors' => true,
]);

// Create a Guzzle client with logging middleware
$stack = GuzzleHandlerStackFactory::createForService('App\Services\StripeService');
$client = new Client([
    'handler' => $stack,
    'base_uri' => 'https://api.stripe.com',
]);

// All requests made with this client will be logged automatically
$response = $client->get('/v1/customers');
```

#### Correlation ID Support

[](#correlation-id-support)

Link related requests across your application:

```
use Ameax\ApiLogger\Support\CorrelationIdManager;

// In your middleware or service provider
$correlationManager = app(CorrelationIdManager::class);

// Will extract from incoming request or generate new one
$correlationId = $correlationManager->getCorrelationId();

// Automatically propagated to outbound requests
$client->post('/api/endpoint', [
    'correlation_id' => $correlationId,
]);
```

#### Service Filtering

[](#service-filtering)

Configure which external services to log:

```
// config/apilogger.php
'features' => [
    'outbound' => [
        'enabled' => true,
        'filters' => [
            'include_hosts' => ['*.stripe.com', 'api.paypal.com'],
            'exclude_hosts' => ['localhost', '127.0.0.1'],
            'include_services' => ['App\Services\PaymentService'],
            'always_log_errors' => true,
        ],
    ],
],
```

### PSR-18 HTTP Client Logging

[](#psr-18-http-client-logging)

ApiLogger supports logging for any PSR-18 compliant HTTP client, including HTTPlug-based libraries like Typesense, Symfony HttpClient, and more.

```
use Ameax\ApiLogger\Outbound\Psr18ClientFactory;
use Http\Discovery\Psr18ClientDiscovery;

// Get base PSR-18 client
$baseClient = Psr18ClientDiscovery::find();

// Wrap with logging
$factory = app(Psr18ClientFactory::class);
$loggingClient = $factory->create($baseClient, [
    'service_class' => App\Services\MyApiService::class,
    'service_name' => 'My API Service',
]);

// All requests with this client are now logged
$response = $loggingClient->sendRequest($request);
```

**For detailed PSR-18 integration guides, architecture information, and troubleshooting:**

- [PSR-18 HTTP Client Support Documentation](docs/psr18-support.md)

**Key Features:**

- Compatible with any PSR-18 client (Symfony HttpClient, Guzzle 7+, etc.)
- Works with HTTPlug-based libraries (Typesense, php-http, etc.)
- Supports HttpMethodsClient wrapper pattern
- Service-based filtering and configuration
- Automatic correlation ID propagation

Exporting API Logs
------------------

[](#exporting-api-logs)

The package includes powerful export functionality for sharing API logs with external partners, debugging in professional tools, or archiving logs in standardized formats.

### Export Formats

[](#export-formats)

#### HAR (HTTP Archive) Format

[](#har-http-archive-format)

Export logs in the [W3C HAR 1.2 specification](http://www.softwareishard.com/blog/har-12-spec/) format, which is compatible with industry-standard tools:

```
use Ameax\ApiLogger\Models\ApiLog;
use Ameax\ApiLogger\Services\Export\HarExportService;

$log = ApiLog::find(123);
$harExport = app(HarExportService::class);

// Generate HAR format
$har = $harExport->generate($log);

// Save to file
file_put_contents('api-log.har', json_encode($har, JSON_PRETTY_PRINT));

// Or return as download response
return response()->json($har)
    ->header('Content-Type', 'application/json')
    ->header('Content-Disposition', 'attachment; filename="api-log.har"');
```

**HAR files can be opened in:**

- **Chrome DevTools** (Network tab → Import HAR file)
- **Firefox Developer Tools** (Network Monitor → Import)
- **Postman** (Import → Raw text)
- **Insomnia** (Import Data → From File)
- **Charles Proxy**, **Fiddler**, and other HTTP debugging tools
- Online viewers like [HAR Viewer](http://www.softwareishard.com/har/viewer/)

**Use Cases:**

- Share API request/response details with external API providers for debugging
- Analyze request/response timing and performance
- Document API behavior with exact request/response examples
- Create test fixtures from real API interactions
- Archive API logs in a standardized, tool-independent format

**HAR Format Features:**

- Complete request details (method, URL, headers, body)
- Full response information (status, headers, body, timing)
- Custom fields for API Logger metadata (correlation ID, service name, retry attempts)
- Standard format ensures compatibility across tools
- JSON-based, human-readable structure

#### HTML Export

[](#html-export)

Export logs as standalone HTML files with inline CSS for easy viewing and sharing:

```
use Ameax\ApiLogger\Models\ApiLog;
use Ameax\ApiLogger\Services\Export\HtmlExportService;

$log = ApiLog::find(123);
$htmlExport = app(HtmlExportService::class);

// Generate HTML
$html = $htmlExport->generate($log);

// Save to file
file_put_contents('api-log.html', $html);

// Or return as download response
return response($html)
    ->header('Content-Type', 'text/html')
    ->header('Content-Disposition', 'attachment; filename="api-log.html"');
```

**HTML Export Features:**

- Standalone HTML file with inline CSS (no external dependencies)
- Syntax-highlighted JSON for request/response bodies
- Color-coded status badges and response times
- Responsive design for viewing on any device
- Professional appearance suitable for client communication
- Print-friendly layout

**Use Cases:**

- Share API logs via email with non-technical stakeholders
- Create printable API documentation
- Archive logs in a human-readable format
- Quick visual inspection without opening specialized tools
- Embed in reports or documentation

### Export Service Architecture

[](#export-service-architecture)

Both export services extend a common base class for code reuse:

```
namespace Ameax\ApiLogger\Services\Export;

// Base class with shared methods
abstract class ApiLogExportService
{
    protected function buildHeaders(?array $headers): array;
    protected function buildQueryString(?array $parameters): array;
    protected function encodeBody(?array $body): string;
    protected function getMimeType(?array $headers, string $default): string;
    protected function getStatusText(int $code): string;
}

// HAR export implementation
class HarExportService extends ApiLogExportService
{
    public function generate(ApiLog $apiLog): array;
}

// HTML export implementation
class HtmlExportService extends ApiLogExportService
{
    public function generate(ApiLog $apiLog): string;
}
```

### Example: Bulk Export

[](#example-bulk-export)

Export multiple logs at once:

```
use Ameax\ApiLogger\Models\ApiLog;
use Ameax\ApiLogger\Services\Export\HarExportService;

$logs = ApiLog::where('service', 'Stripe API')
    ->where('response_code', '>=', 400)
    ->get();

$harExport = app(HarExportService::class);

// Create HAR file with multiple entries
$har = [
    'log' => [
        'version' => '1.2',
        'creator' => [
            'name' => 'API Logger',
            'version' => '1.0',
        ],
        'entries' => $logs->map(fn($log) =>
            $harExport->generate($log)['log']['entries'][0]
        )->all(),
    ],
];

file_put_contents('stripe-errors.har', json_encode($har, JSON_PRETTY_PRINT));
```

### Integration with UI Frameworks

[](#integration-with-ui-frameworks)

The export services are framework-agnostic and can be easily integrated into any UI:

**Filament Example:**

```
use Filament\Actions\Action;
use Ameax\ApiLogger\Services\Export\HarExportService;

Action::make('export_har')
    ->label('Export HAR')
    ->icon('heroicon-o-arrow-down-tray')
    ->action(function (ApiLog $record) {
        $harExport = app(HarExportService::class);
        $har = $harExport->generate($record);

        return response()->streamDownload(
            fn () => print(json_encode($har, JSON_PRETTY_PRINT)),
            sprintf('api-log-%s.har', $record->id),
            ['Content-Type' => 'application/json']
        );
    });
```

**Laravel Livewire Example:**

```
use Livewire\Component;
use Ameax\ApiLogger\Services\Export\HtmlExportService;

class ApiLogViewer extends Component
{
    public function downloadHtml($logId)
    {
        $log = ApiLog::findOrFail($logId);
        $htmlExport = app(HtmlExportService::class);
        $html = $htmlExport->generate($log);

        return response()->streamDownload(
            fn () => print($html),
            "api-log-{$logId}.html"
        );
    }
}
```

Maintenance Commands
--------------------

[](#maintenance-commands)

### Clean Old Logs

[](#clean-old-logs)

```
# Clean logs older than configured retention period
php artisan api-logger:clean

# Clean logs older than specific days
php artisan api-logger:clean --days=60

# Clean with different retention for errors
php artisan api-logger:clean --days=30 --error-days=90
```

### Export Logs

[](#export-logs)

```
# Export logs to JSON
php artisan api-logger:export --format=json --output=logs.json

# Export logs for specific date range
php artisan api-logger:export --from="2024-01-01" --to="2024-01-31"

# Export only errors
php artisan api-logger:export --errors-only
```

Performance Considerations
--------------------------

[](#performance-considerations)

### Circuit Breaker

[](#circuit-breaker)

The package includes a circuit breaker pattern to prevent cascading failures. If storage fails 5 times consecutively, it temporarily stops attempting to store logs.

### Batch Operations

[](#batch-operations)

When storing multiple logs, use batch operations:

```
use Ameax\ApiLogger\StorageManager;

$storage = app(StorageManager::class)->driver();
$storage->storeBatch($logEntries); // Automatically chunks large batches
```

### Response Time Filtering

[](#response-time-filtering)

Reduce storage overhead by only logging slow requests:

```
// config/apilogger.php
'filters' => [
    'min_response_time' => 100, // Only log requests taking > 100ms
],
```

Advanced Usage
--------------

[](#advanced-usage)

### Custom Storage Driver

[](#custom-storage-driver)

Create a custom storage driver by implementing `StorageInterface`:

```
use Ameax\ApiLogger\Contracts\StorageInterface;

class CustomStorage implements StorageInterface
{
    public function store(LogEntry $logEntry): bool
    {
        // Your implementation
    }

    public function retrieve(array $criteria = [], int $limit = 100, int $offset = 0): Collection
    {
        // Your implementation
    }

    // Other required methods...
}

// Register in a service provider
use Ameax\ApiLogger\Facades\ApiLogger;

ApiLogger::extend('custom', function ($app, $config) {
    return new CustomStorage($config);
});
```

### Request Enrichment

[](#request-enrichment)

Add custom data to logs:

```
use Ameax\ApiLogger\Services\RequestCapture;

// In a service provider
$capture = app(RequestCapture::class);

$capture->enrich(function ($request) {
    return [
        'custom_field' => 'custom_value',
        'request_source' => $request->header('X-Request-Source'),
    ];
});
```

### Monitoring Integration

[](#monitoring-integration)

Get storage statistics:

```
use Ameax\ApiLogger\StorageManager;

$storage = app(StorageManager::class)->driver();
$stats = $storage->getStatistics();

// Returns:
// [
//     'total_logs' => 10000,
//     'total_errors' => 500,
//     'avg_response_time' => 150.5,
//     'status_groups' => ['2xx' => 8000, '4xx' => 1500, '5xx' => 500],
//     ...
// ]
```

Testing
-------

[](#testing)

Run the test suite:

```
composer test
```

Run with code coverage:

```
composer test-coverage
```

Troubleshooting
---------------

[](#troubleshooting)

### Logs Not Being Created

[](#logs-not-being-created)

1. Check if logging is enabled:

    ```
    config('apilogger.enabled') // Should be true
    ```
2. Verify the logging level:

    ```
    config('apilogger.level') // Should not be 'none'
    ```
3. Check filters aren't excluding your requests:

    ```
    config('apilogger.filters')
    ```

### Performance Issues

[](#performance-issues)

1. Enable queue processing
2. Increase batch size for bulk operations
3. Use response time filtering
4. Consider using JSON Lines storage for high-volume APIs

### Storage Errors

[](#storage-errors)

1. Check database connection and migrations
2. Verify file permissions for JSON Lines storage
3. Enable fallback storage for redundancy
4. Monitor circuit breaker status in logs

Security
--------

[](#security)

If you discover any security-related issues, please email  instead of using the issue tracker.

Contributing
------------

[](#contributing)

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

Changelog
---------

[](#changelog)

Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.

Credits
-------

[](#credits)

- [Ameax](https://github.com/ameax)
- [All Contributors](../../contributors)

License
-------

[](#license)

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

###  Health Score

26

—

LowBetter than 43% of packages

Maintenance58

Moderate activity, may be stable

Popularity17

Limited adoption so far

Community9

Small or concentrated contributor base

Maturity18

Early-stage or recently created project

 Bus Factor1

Top contributor holds 92.6% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

### Community

Maintainers

![](https://www.gravatar.com/avatar/f67be86f330b5a3e644c8594bbf322be6ab1a08da5434d9cef417097d5567287?d=identicon)[aranes](/maintainers/aranes)

---

Top Contributors

[![ms-aranes](https://avatars.githubusercontent.com/u/69188126?v=4)](https://github.com/ms-aranes "ms-aranes (25 commits)")[![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4)](https://github.com/dependabot[bot] "dependabot[bot] (1 commits)")[![github-actions[bot]](https://avatars.githubusercontent.com/in/15368?v=4)](https://github.com/github-actions[bot] "github-actions[bot] (1 commits)")

---

Tags

apiapi-monitoringlaravelloggingmiddlewaremonitoringphprequest-logging

### Embed Badge

![Health badge](/badges/ameax-apilogger/health.svg)

```
[![Health](https://phpackages.com/badges/ameax-apilogger/health.svg)](https://phpackages.com/packages/ameax-apilogger)
```

###  Alternatives

[psr/log

Common interface for logging libraries

10.4k1.2B9.2k](/packages/psr-log)[itsgoingd/clockwork

php dev tools in your browser

5.9k27.6M94](/packages/itsgoingd-clockwork)[graylog2/gelf-php

A php implementation to send log-messages to a GELF compatible backend like Graylog2.

41838.2M138](/packages/graylog2-gelf-php)[bugsnag/bugsnag-psr-logger

Official Bugsnag PHP PSR Logger.

32132.5M2](/packages/bugsnag-bugsnag-psr-logger)[consolidation/log

Improved Psr-3 / Psr\\Log logger based on Symfony Console components.

15462.2M7](/packages/consolidation-log)[ekino/newrelic-bundle

Integrate New Relic into Symfony2

28111.2M8](/packages/ekino-newrelic-bundle)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)