20486598223

Committed 19 Nov 2025 03:37PM UTC coverage: 62.616% (+0.1%) from 62.5%

Build # 20486598223

Build Type

push

github

Committed by

daycry

Commit Message

- Improvements

Run Details

22 of 25 new or added lines in 12 files covered. (88.0%)

2 existing lines in 1 file now uncovered.

1149 of 1835 relevant lines covered (62.62%)

4.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.11

/src/Libraries/InstrumentedQueueDecorator.php

<?php

declare(strict_types=1);

/**
 * This file is part of Daycry Queues.
 *
 * (c) Daycry <daycry9@proton.me>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace Daycry\Jobs\Libraries;

use Daycry\Jobs\Interfaces\QueueInterface;
use Daycry\Jobs\Interfaces\WorkerInterface;
use Daycry\Jobs\Job;
use Daycry\Jobs\Metrics\MetricsCollectorInterface;
use InvalidArgumentException;
use Throwable;

/**
 * Decorator transparente que instrumenta cualquier QueueInterface con métricas.
 *
 * Métricas capturadas:
 *  - queue_enqueue_total: Contador de jobs enqueued
 *  - queue_fetch_total: Contador de watch() exitosos
 *  - queue_fetch_empty_total: Contador de watch() sin jobs
 *  - queue_ack_total: Contador de removeJob success
 *  - queue_nack_total: Contador de removeJob con recreate
 *  - queue_enqueue_duration_seconds: Histograma de latencia de enqueue
 *  - queue_fetch_duration_seconds: Histograma de latencia de watch
 *
 * Uso:
 *   $redis = new RedisQueue();
 *   $instrumented = new InstrumentedQueueDecorator($redis, $metricsCollector, 'redis');
 *   $id = $instrumented->enqueue($data); // métricas capturadas automáticamente
 */
class InstrumentedQueueDecorator implements QueueInterface, WorkerInterface
{
    private QueueInterface $decorated;
    private MetricsCollectorInterface $metrics;
    private string $backendName;

    public function __construct(
        QueueInterface $decorated,
        MetricsCollectorInterface $metrics,
        string $backendName,
    ) {
        // Validar que también implementa WorkerInterface
        if (! $decorated instanceof WorkerInterface) {
            throw new InvalidArgumentException('Decorated queue must implement WorkerInterface');
        }
        $this->decorated   = $decorated;
        $this->metrics     = $metrics;
        $this->backendName = $backendName;
    }

    public function enqueue(object $data): string
    {
        $start = microtime(true);
        $queue = $data->queue ?? 'default';

        try {
            $id = $this->decorated->enqueue($data);
            $this->metrics->increment('queue_enqueue_total', 1, [
                'backend' => $this->backendName,
                'queue'   => $queue,
                'status'  => 'success',
            ]);

            return $id;
        } catch (Throwable $e) {
            $this->metrics->increment('queue_enqueue_total', 1, [
                'backend' => $this->backendName,
                'queue'   => $queue,
                'status'  => 'error',
            ]);

            throw $e;
        } finally {
            $duration = microtime(true) - $start;
            $this->metrics->observe('queue_enqueue_duration_seconds', $duration, [
                'backend' => $this->backendName,
                'queue'   => $queue,
            ]);
        }
    }

    public function watch(string $queue)
    {
        $start = microtime(true);

        try {
            /** @var WorkerInterface $worker */
            $worker   = $this->decorated;
            $envelope = $worker->watch($queue);

            if ($envelope !== null) {
                $this->metrics->increment('queue_fetch_total', 1, [
                    'backend' => $this->backendName,
                    'queue'   => $queue,
                ]);
            } else {
                $this->metrics->increment('queue_fetch_empty_total', 1, [
                    'backend' => $this->backendName,
                    'queue'   => $queue,
                ]);
            }

            return $envelope;
        } finally {
            $duration = microtime(true) - $start;
            $this->metrics->observe('queue_fetch_duration_seconds', $duration, [
                'backend' => $this->backendName,
                'queue'   => $queue,
            ]);
        }
    }

    public function removeJob(Job $job, bool $recreate = false): bool
    {
        /** @var WorkerInterface $worker */
        $worker = $this->decorated;
        $result = $worker->removeJob($job, $recreate);

        $metricName = $recreate ? 'queue_nack_total' : 'queue_ack_total';
        $this->metrics->increment($metricName, 1, [
            'backend' => $this->backendName,
            'queue'   => $job->getQueue() ?? 'unknown',
        ]);

        return $result;
    }

    /**
     * Acceso al backend decorado (útil para operaciones especializadas).
     */
    public function getDecorated(): QueueInterface
    {
        return $this->decorated;
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	/**
6	* This file is part of Daycry Queues.
7	*
8	* (c) Daycry <daycry9@proton.me>
9	*
10	* For the full copyright and license information, please view
11	* the LICENSE file that was distributed with this source code.
12	*/
13
14	namespace Daycry\Jobs\Libraries;
15
16	use Daycry\Jobs\Interfaces\QueueInterface;
17	use Daycry\Jobs\Interfaces\WorkerInterface;
18	use Daycry\Jobs\Job;
19	use Daycry\Jobs\Metrics\MetricsCollectorInterface;
20	use InvalidArgumentException;
21	use Throwable;
22
23	/**
24	* Decorator transparente que instrumenta cualquier QueueInterface con métricas.
25	*
26	* Métricas capturadas:
27	* - queue_enqueue_total: Contador de jobs enqueued
28	* - queue_fetch_total: Contador de watch() exitosos
29	* - queue_fetch_empty_total: Contador de watch() sin jobs
30	* - queue_ack_total: Contador de removeJob success
31	* - queue_nack_total: Contador de removeJob con recreate
32	* - queue_enqueue_duration_seconds: Histograma de latencia de enqueue
33	* - queue_fetch_duration_seconds: Histograma de latencia de watch
34	*
35	* Uso:
36	* $redis = new RedisQueue();
37	* $instrumented = new InstrumentedQueueDecorator($redis, $metricsCollector, 'redis');
38	* $id = $instrumented->enqueue($data); // métricas capturadas automáticamente
39	*/
40	class InstrumentedQueueDecorator implements QueueInterface, WorkerInterface
41	{
42	private QueueInterface $decorated;
43	private MetricsCollectorInterface $metrics;
44	private string $backendName;
45
46	public function __construct(
47	QueueInterface $decorated,
48	MetricsCollectorInterface $metrics,
49	string $backendName,
50	) {
51	// Validar que también implementa WorkerInterface
52	if (! $decorated instanceof WorkerInterface) {	9✔
NEW 53	throw new InvalidArgumentException('Decorated queue must implement WorkerInterface');	×
54	}
55	$this->decorated = $decorated;	9✔
56	$this->metrics = $metrics;	9✔
57	$this->backendName = $backendName;	9✔
58	}
59
60	public function enqueue(object $data): string
61	{
62	$start = microtime(true);	3✔
63	$queue = $data->queue ?? 'default';	3✔
64
65	try {
66	$id = $this->decorated->enqueue($data);	3✔
67	$this->metrics->increment('queue_enqueue_total', 1, [	2✔
68	'backend' => $this->backendName,	2✔
69	'queue' => $queue,	2✔
70	'status' => 'success',	2✔
71	]);	2✔
72
73	return $id;	2✔
74	} catch (Throwable $e) {	1✔
75	$this->metrics->increment('queue_enqueue_total', 1, [	1✔
76	'backend' => $this->backendName,	1✔
77	'queue' => $queue,	1✔
78	'status' => 'error',	1✔
79	]);	1✔
80
81	throw $e;	1✔
82	} finally {
83	$duration = microtime(true) - $start;	3✔
84	$this->metrics->observe('queue_enqueue_duration_seconds', $duration, [	3✔
85	'backend' => $this->backendName,	3✔
86	'queue' => $queue,	3✔
87	]);	3✔
88	}
89	}
90
91	public function watch(string $queue)
92	{
93	$start = microtime(true);	3✔
94
95	try {
96	/** @var WorkerInterface $worker */
97	$worker = $this->decorated;	3✔
98	$envelope = $worker->watch($queue);	3✔
99
100	if ($envelope !== null) {	3✔
101	$this->metrics->increment('queue_fetch_total', 1, [	1✔
102	'backend' => $this->backendName,	1✔
103	'queue' => $queue,	1✔
104	]);	1✔
105	} else {
106	$this->metrics->increment('queue_fetch_empty_total', 1, [	2✔
107	'backend' => $this->backendName,	2✔
108	'queue' => $queue,	2✔
109	]);	2✔
110	}
111
112	return $envelope;	3✔
113	} finally {
114	$duration = microtime(true) - $start;	3✔
115	$this->metrics->observe('queue_fetch_duration_seconds', $duration, [	3✔
116	'backend' => $this->backendName,	3✔
117	'queue' => $queue,	3✔
118	]);	3✔
119	}
120	}
121
122	public function removeJob(Job $job, bool $recreate = false): bool
123	{
124	/** @var WorkerInterface $worker */
125	$worker = $this->decorated;	2✔
126	$result = $worker->removeJob($job, $recreate);	2✔
127
128	$metricName = $recreate ? 'queue_nack_total' : 'queue_ack_total';	2✔
129	$this->metrics->increment($metricName, 1, [	2✔
130	'backend' => $this->backendName,	2✔
131	'queue' => $job->getQueue() ?? 'unknown',	2✔
132	]);	2✔
133
134	return $result;	2✔
135	}
136
137	/**
138	* Acceso al backend decorado (útil para operaciones especializadas).
139	*/
140	public function getDecorated(): QueueInterface
141	{
142	return $this->decorated;	1✔
143	}
144	}

daycry / jobs / 20486598223

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous