PHPackages                             gladehq/laravel-event-lens - 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. gladehq/laravel-event-lens

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

gladehq/laravel-event-lens
==========================

Deep observability for Laravel Events and Listeners with execution tracing and waterfall visualization.

01PHPCI passing

Since Feb 15Pushed 4mo agoCompare

[ Source](https://github.com/gladehq/laravel-event-lens)[ Packagist](https://packagist.org/packages/gladehq/laravel-event-lens)[ RSS](/packages/gladehq-laravel-event-lens/feed)WikiDiscussions master Synced today

READMEChangelog (1)DependenciesVersions (1)Used By (0)

 [![Latest Version](https://camo.githubusercontent.com/5a903fe6861ac34a96182523669b490db0aeb17fd4292f450debd02e2db35b38/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f676c61646568712f6c61726176656c2d6576656e742d6c656e73)](https://camo.githubusercontent.com/5a903fe6861ac34a96182523669b490db0aeb17fd4292f450debd02e2db35b38/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f676c61646568712f6c61726176656c2d6576656e742d6c656e73) [![PHP Version](https://camo.githubusercontent.com/314cad0a33d00ebe09f7b07ca10a739036fca5e362db36c6a88c5d515267d50d/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f7068702d762f676c61646568712f6c61726176656c2d6576656e742d6c656e73)](https://camo.githubusercontent.com/314cad0a33d00ebe09f7b07ca10a739036fca5e362db36c6a88c5d515267d50d/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f7068702d762f676c61646568712f6c61726176656c2d6576656e742d6c656e73) [![Laravel Version](https://camo.githubusercontent.com/a0cfcd4ae10ce58c14aafcab200fa0c44994a20f1da44fa3ae27efbca47abb51/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c61726176656c2d3130253230253743253230313125323025374325323031322d464632443230)](https://camo.githubusercontent.com/a0cfcd4ae10ce58c14aafcab200fa0c44994a20f1da44fa3ae27efbca47abb51/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c61726176656c2d3130253230253743253230313125323025374325323031322d464632443230) [![License](https://camo.githubusercontent.com/d5a5ed1e4a70f5b2832f7a985bc8750af0957d968a82493af8db22efeb87124e/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f6c2f676c61646568712f6c61726176656c2d6576656e742d6c656e73)](https://camo.githubusercontent.com/d5a5ed1e4a70f5b2832f7a985bc8750af0957d968a82493af8db22efeb87124e/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f6c2f676c61646568712f6c61726176656c2d6576656e742d6c656e73) [![Tests](https://camo.githubusercontent.com/4a415b7923accae74ffe2e4f419fe7b3b7d9f48c60c39a8d0a45054d78c6140a/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f74657374732d3331382532307061737365642d627269676874677265656e)](https://camo.githubusercontent.com/4a415b7923accae74ffe2e4f419fe7b3b7d9f48c60c39a8d0a45054d78c6140a/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f74657374732d3331382532307061737365642d627269676874677265656e)

Laravel Event Lens
==================

[](#laravel-event-lens)

**Deep observability for Laravel Events and Listeners.** Trace every dispatch, measure every listener, catch every anomaly — with zero changes to your existing event code.

Event Lens intercepts Laravel's event dispatcher to record execution traces with parent-child hierarchy, side-effect counts, payload snapshots, and millisecond-precision timing. The built-in dashboard provides waterfall visualization, health monitoring, flow mapping, and anomaly detection.

---

Table of Contents
-----------------

[](#table-of-contents)

- [Requirements](#requirements)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [Configuration](#configuration)
- [Dashboard](#dashboard)
- [Event Tagging](#event-tagging)
- [Model Linking](#model-linking)
- [Custom Watchers](#custom-watchers)
- [Health Monitoring](#health-monitoring)
- [Anomaly Detection](#anomaly-detection)
- [Notification Alerts](#notification-alerts)
- [Event Flow Map](#event-flow-map)
- [Comparison Mode](#comparison-mode)
- [Event Replay](#event-replay)
- [OpenTelemetry Export](#opentelemetry-export)
- [JSON API](#json-api)
- [CI Integration](#ci-integration)
- [Testing Utilities](#testing-utilities)
- [Artisan Commands](#artisan-commands)
- [Environment Variables](#environment-variables)
- [Octane Support](#octane-support)
- [Queue Tracing](#queue-tracing)
- [How It Differs from Telescope](#how-it-differs-from-telescope)
- [License](#license)

---

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

[](#requirements)

- PHP 8.2+
- Laravel 10, 11, or 12

No additional PHP extensions or JS build tools required.

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

[](#installation)

```
composer require gladehq/laravel-event-lens
```

```
php artisan event-lens:install
```

This publishes the config file and runs migrations. That's it — visit `/event-lens` to see the dashboard.

Manual installation```
php artisan vendor:publish --tag=event-lens-config
php artisan migrate
```

Optionally publish views for customization:

```
php artisan vendor:publish --tag=event-lens-views
```

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

[](#quick-start)

Event Lens works out of the box. Once installed, every event in the `App\Events\*` namespace is automatically traced. No code changes needed.

```
// This is already being traced
OrderPlaced::dispatch($order);
```

Visit `/event-lens` to see:

- The event dispatch and listener execution as a waterfall trace
- Query count, mail count, and HTTP calls per listener
- Payload snapshot with automatic redaction of sensitive keys
- Model changes captured from dirty Eloquent models
- Exception details with stack traces if a listener failed

---

Configuration
-------------

[](#configuration)

All options are in `config/event-lens.php`:

### Core

[](#core)

KeyDefaultDescription`enabled``true`Master switch`sampling_rate``1.0`Percentage of events to record (0.0-1.0)`namespaces``['App\Events\*']`Event class patterns to monitor (wildcards supported)`ignore``[]`Event patterns to exclude, even if they match namespaces`capture_backtrace``false`Record file/line where events are dispatched. **Dev only** — expensive`redacted_keys``['password', 'token', ...]`Keys scrubbed from payloads before storage (case-insensitive)### Dashboard

[](#dashboard)

KeyDefaultDescription`authorization``null`Closure receiving `$user`, return `true` to allow access. Default: local env only`middleware``['web']`Middleware stack for dashboard routes`path``'event-lens'`URL prefix### Storage & Retention

[](#storage--retention)

KeyDefaultDescription`database_connection``null`Separate DB connection for storage (`null` = app default)`prune_after_days``7`Days to retain data. Pruning runs daily via scheduler`buffer_size``1000`Max in-memory events before auto-flush to database### Detection Thresholds

[](#detection-thresholds)

KeyDefaultDescription`slow_threshold``100.0`Milliseconds before flagging as slow`storm_threshold``50`Same-event dispatches per correlation before flagging as storm`stale_threshold_days``30`Days of inactivity before a listener is considered stale`regression_threshold``2.0`Multiplier for flagging performance regressions (e.g. 2.0 = 2x slower)### SLA Budgets

[](#sla-budgets)

```
'sla_budgets' => [
    'App\Listeners\SendEmail' => 500,     // 500ms budget
    'App\Events\OrderPlaced' => 200,      // 200ms for all listeners
    'App\Events\*' => 1000,              // Wildcard fallback
],
```

Resolution order: exact listener name > exact event name > wildcard pattern.

### Side-Effect Watchers

[](#side-effect-watchers)

```
'watchers' => [
    \GladeHQ\LaravelEventLens\Watchers\QueryWatcher::class,
    \GladeHQ\LaravelEventLens\Watchers\MailWatcher::class,
    \GladeHQ\LaravelEventLens\Watchers\HttpWatcher::class,
],
```

### Advanced

[](#advanced)

KeyDefaultDescription`allow_replay``false`Enable event replay from dashboard. **Use with caution**`otlp_endpoint``null`OTLP endpoint for trace export`otlp_service_name``null`Service name in OTLP resource attributes`alerts.enabled``false`Enable Slack/mail/log alert notifications`alerts.channels``[]`Any combination of `'slack'`, `'mail'`, `'log'``alerts.slack_webhook``null`Slack incoming webhook URL`alerts.mail_to``null`Email address for alerts`alerts.cooldown_minutes``15`Minutes between repeated alerts of the same type`alerts.on``['storm', 'sla_breach', ...]`Alert types to enable---

Dashboard
---------

[](#dashboard-1)

Visit `/event-lens` (or your configured path). Access is restricted to the `local` environment by default.

### Authorization

[](#authorization)

```
// config/event-lens.php
'authorization' => function ($user) {
    return $user && $user->isAdmin();
},
```

### Pages

[](#pages)

**Stream** — Live event feed with real-time polling. Filter by event name, listener name, payload content, tags, date range, or toggle slow/errors/storms/SLA breaches/drift/N+1. Each row shows inline badges for all detected anomalies, request context (HTTP method + path, CLI command, or queue job), and a copy button for correlation IDs.

**Statistics** — Three-tab analytics dashboard:

- **Overview**: Daily volume chart with error overlay, execution time distribution histogram, event mix composition
- **Performance**: Top events by frequency with per-listener breakdown, slowest events, heaviest by query load
- **Errors**: Exception breakdown grouped by type with counts

**Health** — Five-tab diagnostic dashboard:

- **Audit**: Dead listeners, orphan events, stale listeners
- **Listener Health**: 0-100 reliability scores based on error rate, P95 latency, and query volume
- **SLA Compliance**: Budget vs actual execution time with compliance percentage
- **Blast Radius**: Event-to-listener dependency map with error/slow indicators
- **Regressions**: Listeners whose recent performance has degraded vs historical baseline

**Flow Map** — Directed graph visualization of event-to-listener relationships. SVG-based with edge colors indicating health (green to red) and thickness proportional to volume. Time range selector: 1h, 6h, 24h, 7d.

**Compare** — Side-by-side period analysis. Summary cards for throughput/latency/error rate deltas. Per-listener breakdown table sorted by degradation. Presets: hour, day, week.

**Waterfall** — Per-correlation execution tree with timing bars, side-effect counts, error propagation badges on ancestor nodes, compact/detailed toggle, and OTLP export button.

**Detail** — Single event deep-dive with payload inspection, exception context with collapsible stack trace, model changes as before/after diff table, tags, and event replay button.

---

Event Tagging
-------------

[](#event-tagging)

Add structured metadata to events by implementing `Taggable`:

```
use GladeHQ\LaravelEventLens\Contracts\Taggable;

class OrderPlaced implements Taggable
{
    public function __construct(
        public Order $order,
        public string $channel,
    ) {}

    public function eventLensTags(): array
    {
        return [
            'channel' => $this->channel,
            'priority' => $this->order->total > 1000 ? 'high' : 'normal',
        ];
    }
}
```

Tags appear as purple badges on the stream and are searchable via the "Tag Contains" filter.

---

Model Linking
-------------

[](#model-linking)

Associate Eloquent models with their event history:

```
use GladeHQ\LaravelEventLens\Concerns\HasEventLens;

class Order extends Model
{
    use HasEventLens;
}

// Query events for a specific order
$order->eventLogs()->latest()->get();
```

Event Lens automatically detects Eloquent models in event public properties and stores `model_type`/`model_id` for polymorphic lookups. Dirty model state is captured as before/after change diffs.

---

Custom Watchers
---------------

[](#custom-watchers)

Track additional side effects by implementing `WatcherInterface`:

```
use GladeHQ\LaravelEventLens\Contracts\WatcherInterface;

class RedisWatcher implements WatcherInterface
{
    protected array $stack = [];

    public function boot(): void
    {
        // Register listeners for Redis commands
    }

    public function start(): void
    {
        $this->stack[] = 0;
    }

    public function stop(): array
    {
        return ['redis' => array_pop($this->stack) ?? 0];
    }

    public function reset(): void
    {
        $this->stack = [];
    }
}
```

Register it:

```
// config/event-lens.php
'watchers' => [
    \GladeHQ\LaravelEventLens\Watchers\QueryWatcher::class,
    \GladeHQ\LaravelEventLens\Watchers\MailWatcher::class,
    \GladeHQ\LaravelEventLens\Watchers\HttpWatcher::class,
    \App\Watchers\RedisWatcher::class,
],
```

Watchers use a stack-based scoping model to correctly attribute side effects to nested event chains.

---

Health Monitoring
-----------------

[](#health-monitoring)

### Listener Health Scores

[](#listener-health-scores)

Each listener gets a 0-100 reliability score:

FactorWeightPenaltyError rateHigh-40 at 100% errorsP95 latencyMedium-30 when exceeding slow thresholdQuery volumeLow-10 for high query countsScores are color-coded: green (80+), yellow (50-79), red (below 50).

### Dead Listener Audit

[](#dead-listener-audit)

The audit tab cross-references your registered listeners (from `EventServiceProvider`) against recorded execution data. Listeners that are registered but have zero executions are flagged as dead — potential code to remove.

### Blast Radius

[](#blast-radius)

Maps each event to all its listeners with error and slow counts. Helps identify high-risk events whose failures would cascade through many listeners.

---

Anomaly Detection
-----------------

[](#anomaly-detection)

Event Lens detects five types of anomalies automatically:

AnomalyBadgeHow It's Detected**Storm**RedSame event class fires > `storm_threshold` times in one correlation**N+1**OrangeIdentical SQL fingerprint repeated 5+ times, or same event dispatched 5+ times**SLA Breach**OrangeExecution time exceeds configured budget**Schema Drift**BluePayload structure changes from recorded baseline (added/removed keys, type changes)**Regression**Severity-coloredRecent 24h average exceeds 7-day baseline by `regression_threshold`All anomalies are filterable on the stream page and surfaced in the health dashboard.

---

Notification Alerts
-------------------

[](#notification-alerts)

Get notified on Slack, email, or log when anomalies occur:

```
// config/event-lens.php
'alerts' => [
    'enabled' => true,
    'channels' => ['slack', 'mail'],
    'slack_webhook' => env('EVENT_LENS_SLACK_WEBHOOK'),
    'mail_to' => env('EVENT_LENS_ALERT_MAIL_TO'),
    'cooldown_minutes' => 15,
    'on' => ['storm', 'sla_breach', 'regression', 'error_spike'],
],
```

Alert TypeTriggerTiming`storm`Event exceeds storm thresholdInline during recording`sla_breach`Listener exceeds time budgetInline during recording`regression`Critical severity regression detectedScheduled (every 5 min)`error_spike`Error rate exceeds 10% with minimum volumeScheduled (every 5 min)Per-type cooldown prevents notification fatigue. Alerts use atomic `Cache::add()` for thread-safe cooldown tracking.

---

Event Flow Map
--------------

[](#event-flow-map)

The `/event-lens/flow-map` page renders a directed graph of your event-to-listener architecture:

- **Event nodes** (indigo) on the left, **Listener nodes** (emerald) on the right
- **Edges** colored by health: green (healthy), amber (slow), red (error-prone)
- **Edge thickness** proportional to execution count
- **Time range selector**: 1h, 6h, 24h, 7d
- **Zoom controls** with SVG viewBox manipulation
- **Connection details table** below the graph with exact counts, avg time, and error rates

Built with server-rendered SVG and Alpine.js — no D3, Mermaid, or external JS dependencies.

---

Comparison Mode
---------------

[](#comparison-mode)

The `/event-lens/comparison` page provides before/after analysis:

- **Summary cards**: Throughput delta, average time delta, error rate delta (with percentage changes)
- **Listener breakdown**: Per-listener table sorted by degradation with status badges
- **Presets**: Last hour vs previous, Today vs yesterday, This week vs last week

Useful for evaluating the impact of deployments, config changes, or traffic shifts.

---

Event Replay
------------

[](#event-replay)

Re-dispatch previously recorded events from the detail page:

```
// config/event-lens.php
'allow_replay' => env('EVENT_LENS_ALLOW_REPLAY', false),
```

When enabled, root events show a "Replay" button. The original payload is deserialized (with internal metadata stripped) and the event is re-dispatched through Laravel's event system.

**Safety**: Disabled by default. Replayed events trigger the full listener pipeline including side effects (emails, DB writes, API calls). Enable only in development or staging.

---

OpenTelemetry Export
--------------------

[](#opentelemetry-export)

Export event traces as OTLP spans to any OpenTelemetry-compatible backend (Jaeger, Zipkin, Datadog, Honeycomb). No additional PHP packages required — uses Laravel's HTTP client.

```
// config/event-lens.php
'otlp_endpoint' => env('EVENT_LENS_OTLP_ENDPOINT'),        // e.g. https://otel.example.com
'otlp_service_name' => env('EVENT_LENS_OTLP_SERVICE_NAME'), // e.g. my-app
```

When configured, the waterfall page shows an "Export Trace" button. Each event log becomes a span with:

- `traceId` derived from the correlation ID
- `spanId` derived from the event ID
- `parentSpanId` linking to parent span
- Attributes: `event.name`, `event.listener`, `db.query_count`, `mail.count`, `http.call_count`, `error`, `exception.message`, `event_lens.storm`, `event_lens.sla_breach`

---

JSON API
--------

[](#json-api)

All dashboard endpoints support content negotiation. Send `Accept: application/json` to get JSON:

```
# Event stream
curl -H "Accept: application/json" https://your-app.com/event-lens

# Statistics
curl -H "Accept: application/json" https://your-app.com/event-lens/statistics

# Health
curl -H "Accept: application/json" https://your-app.com/event-lens/health

# Trace waterfall
curl -H "Accept: application/json" https://your-app.com/event-lens/{correlationId}

# Comparison
curl -H "Accept: application/json" https://your-app.com/event-lens/comparison?preset=day

# Polling endpoint (always JSON)
curl https://your-app.com/event-lens/api/latest?after_id=100
```

---

CI Integration
--------------

[](#ci-integration)

Gate deployments on SLA compliance:

```
php artisan event-lens:assert-performance --period=24h --format=json
```

- Exit code `0`: All SLA budgets met
- Exit code `1`: Breaches found

```
# GitHub Actions example
- name: Assert performance SLAs
  run: php artisan event-lens:assert-performance --period=24h --format=json
```

---

Testing Utilities
-----------------

[](#testing-utilities)

Event Lens includes a test trait for asserting event behavior in your test suite:

```
use GladeHQ\LaravelEventLens\Testing\AssertsEventLens;

class OrderTest extends TestCase
{
    use AssertsEventLens;

    protected function setUp(): void
    {
        parent::setUp();
        $this->setUpEventLens(); // Swaps to in-memory buffer
    }

    protected function tearDown(): void
    {
        $this->tearDownEventLens();
        parent::tearDown();
    }

    public function test_order_placement_triggers_correct_chain(): void
    {
        OrderPlaced::dispatch($this->order);

        $this->assertEventDispatched(OrderPlaced::class);
        $this->assertEventLensChain(OrderPlaced::class, [
            SendConfirmationEmail::class,
            UpdateInventory::class,
            NotifyWarehouse::class,
        ]);
        $this->assertListenerUnder(SendConfirmationEmail::class, 500);
        $this->assertNoExceptions();
    }
}
```

### Available Assertions

[](#available-assertions)

MethodDescription`assertEventDispatched($event, $callback?)`Assert event was dispatched. Optional callback receives each record`assertEventNotDispatched($event)`Assert event was not dispatched`assertEventLensChain($event, $listeners)`Assert event triggered exact listener chain in order`assertListenerExecuted($listener)`Assert listener was executed at least once`assertListenerUnder($listener, $maxMs)`Assert all executions completed within time threshold`assertNoExceptions()`Assert no recorded events contain exceptions---

Artisan Commands
----------------

[](#artisan-commands)

CommandDescription`event-lens:install`Publish config and run migrations`event-lens:status`Show status, event count, sampling rate, monitored namespaces`event-lens:clear --force`Truncate all event data`event-lens:prune --days=7 --dry-run`Delete old events. `--dry-run` previews without deleting`event-lens:audit`Dead listener, orphan event, and stale listener audit`event-lens:check-alerts`Check for anomalies and fire notifications`event-lens:trace {correlationId} --json`Display trace tree in terminal with color-coded output`event-lens:assert-performance --period=24h --format=json`Assert SLA compliance (exit 0/1 for CI)Pruning and alert checking are auto-scheduled when configured — no manual cron entries needed.

---

Environment Variables
---------------------

[](#environment-variables)

```
# Core
EVENT_LENS_ENABLED=true
EVENT_LENS_SAMPLING_RATE=1.0
EVENT_LENS_BACKTRACE=false

# Replay
EVENT_LENS_ALLOW_REPLAY=false

# OpenTelemetry
EVENT_LENS_OTLP_ENDPOINT=https://otel.example.com
EVENT_LENS_OTLP_SERVICE_NAME=my-app

# Alerts
EVENT_LENS_ALERTS_ENABLED=false
EVENT_LENS_SLACK_WEBHOOK=https://hooks.slack.com/services/...
EVENT_LENS_ALERT_MAIL_TO=admin@example.com
EVENT_LENS_ALERT_COOLDOWN=15
```

Complex values (namespaces, ignore list, SLA budgets, watchers) must be configured in `config/event-lens.php` directly.

---

Octane Support
--------------

[](#octane-support)

Event Lens automatically resets all singleton state between Octane requests:

- Buffer flush
- Recorder state (call stack, correlation context, storm counters)
- All watcher stacks
- Request context resolver
- N+1 detector
- Schema tracker baseline cache

No configuration needed. Detected via `Laravel\Octane\Events\RequestReceived`.

---

Queue Tracing
-------------

[](#queue-tracing)

Correlation IDs propagate automatically into queued job payloads via `Queue::createPayloadUsing()`. Events dispatched inside a queued job inherit the parent correlation ID, linking traces across sync and async boundaries.

No configuration needed.

---

How It Differs from Telescope
-----------------------------

[](#how-it-differs-from-telescope)

CapabilityTelescopeEvent LensFocusFull request lifecycleEvents & listenersParent-child tracing-Correlation + hierarchyWaterfall visualization-Interactive timing barsSide-effect tracking per listener-Queries, mails, HTTP callsModel change tracking-Dirty state diffsPolymorphic model linking-`HasEventLens` traitCross-queue correlation-Automatic propagationCustom watchers-Pluggable `WatcherInterface`Event tagging-`Taggable` interfaceStorm detection-Configurable thresholdN+1 detection-Query + event patternsSLA enforcement-Time budgets with complianceSchema drift detection-Payload fingerprintingRegression detection-Baseline comparisonDead listener audit-Health dashboardListener health scores-0-100 reliabilityBlast radius mapping-Dependency visualizationEvent flow map-Directed graphEvent replay-Dashboard buttonOpenTelemetry export-Native OTLP spansNotification alerts-Slack, mail, logComparison mode-Period-over-periodCI assertion-Exit code gatingJSON API-Content negotiationFootprintHeavyLightweight---

License
-------

[](#license)

MIT License. See [LICENSE](LICENSE) for details.

###  Health Score

18

—

LowBetter than 8% of packages

Maintenance51

Moderate activity, may be stable

Popularity1

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity12

Early-stage or recently created project

 Bus Factor1

Top contributor holds 100% 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/130d3ca03c3035d1d05d614d5555b3956c254b774bd550bbb80ed35bb99b4ad4?d=identicon)[dulithamahishka94](/maintainers/dulithamahishka94)

---

Top Contributors

[![dulithamahishka94](https://avatars.githubusercontent.com/u/64469682?v=4)](https://github.com/dulithamahishka94 "dulithamahishka94 (91 commits)")

---

Tags

composereventslaravellaravel-frameworklistenersobservabilitypackage

### Embed Badge

![Health badge](/badges/gladehq-laravel-event-lens/health.svg)

```
[![Health](https://phpackages.com/badges/gladehq-laravel-event-lens/health.svg)](https://phpackages.com/packages/gladehq-laravel-event-lens)
```

###  Alternatives

[psr/log

Common interface for logging libraries

10.4k1.2B11.5k](/packages/psr-log)[open-telemetry/api

API for OpenTelemetry PHP.

1941.5M276](/packages/open-telemetry-api)[open-telemetry/sdk

SDK for OpenTelemetry PHP.

2328.5M343](/packages/open-telemetry-sdk)

PHPackages © 2026

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