13008726707

Committed 28 Jan 2025 10:45AM UTC coverage: 88.543% (+0.2%) from 88.352%

Build # 13008726707

Build Type

push

github

Committed by

gaelreyrol

Commit Message

chore(github): use fossa push only API token

Run Details

2048 of 2313 relevant lines covered (88.54%)

6.93 hits per line

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

98.7

/src/DependencyInjection/OpenTelemetryLogsExtension.php

<?php

namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection;

use FriendsOfOpenTelemetry\OpenTelemetryBundle\OpenTelemetry\Exporter\ExporterOptionsInterface;
use FriendsOfOpenTelemetry\OpenTelemetryBundle\OpenTelemetry\Log\LogProcessor\LogProcessorEnum;
use Monolog\Level;
use OpenTelemetry\API\Common\Time\ClockInterface;
use OpenTelemetry\Contrib\Logs\Monolog\Handler;
use Symfony\Component\DependencyInjection\ChildDefinition;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;

/**
 * @phpstan-import-type ExporterOptions from ExporterOptionsInterface
 */
final class OpenTelemetryLogsExtension
{
    /**
     * @var array<string, mixed>
     */
    private array $config;
    private ContainerBuilder $container;

    /**
     * @param array{
     *     monolog: array<string, mixed>,
     *     loggers: array<string, mixed>,
     *     exporters: array<string, mixed>,
     *     processors: array<string, mixed>,
     *     providers: array<string, mixed>
     * }|array<string, mixed> $config
     */
    public function __invoke(array $config, ContainerBuilder $container): void
    {
        $this->config = $config;
        $this->container = $container;

        foreach ($this->config['exporters'] as $name => $exporter) {
            $this->loadLogExporter($name, $exporter);
        }

        foreach ($this->config['processors'] as $name => $processor) {
            $this->loadLogProcessor($name, $processor);
        }

        foreach ($this->config['providers'] as $name => $provider) {
            $this->loadLogProvider($name, $provider);
        }

        foreach ($this->config['loggers'] as $name => $logger) {
            $this->loadLogLogger($name, $logger);
        }

        $defaultLogger = null;
        if (0 < count($this->config['loggers'])) {
            $defaultLogger = array_key_first($this->config['loggers']);
        }

        if (null !== $defaultLogger) {
            $this->container->setAlias('open_telemetry.logs.default_logger', new Reference(sprintf('open_telemetry.logs.loggers.%s', $defaultLogger)));
        }

        $this->loadMonologHandlers();
    }

    /**
     * @param array{
     *      dsn: string,
     *      options?: ExporterOptions
     *  } $config
     */
    private function loadLogExporter(string $name, array $config): void
    {
        $dsn = (new ChildDefinition('open_telemetry.exporter_dsn'))->setArguments([$config['dsn']]);
        $exporterOptions = (new ChildDefinition('open_telemetry.otlp_exporter_options'))->setArguments([$config['options'] ?? []]);

        $this->container
            ->setDefinition(
                sprintf('open_telemetry.logs.exporters.%s', $name),
                new ChildDefinition('open_telemetry.logs.exporter_interface'),
            )
            ->setArguments([$dsn, $exporterOptions]);
    }

    /**
     * @param array{
     *      type: string,
     *      processors?: string[],
     *      batch?: array{
     *          clock: class-string<ClockInterface>,
     *          max_queue_size: int,
     *          schedule_delay: int,
     *          export_timeout: int,
     *          max_export_batch_size: int,
     *          auto_flush: bool,
     *          meter_provider?: string,
     *      },
     *      exporter?: string
     *  } $config
     */
    private function loadLogProcessor(string $name, array $config): void
    {
        $this->container
            ->setDefinition(
                sprintf('open_telemetry.logs.processors.%s', $name),
                new ChildDefinition('open_telemetry.logs.processor_interface')
            )
            ->setFactory([new Reference(sprintf('open_telemetry.logs.processor_factory.%s', $config['type'])), 'createProcessor'])
            ->setArguments([
                array_map(fn (string $processor) => new Reference($processor), $config['processors'] ?? []),
                LogProcessorEnum::Batch->value === $config['type'] && isset($config['batch']) ? [
                    'clock' => new Reference($config['batch']['clock']),
                    'max_queue_size' => $config['batch']['max_queue_size'],
                    'schedule_delay' => $config['batch']['schedule_delay'],
                    'export_timeout' => $config['batch']['export_timeout'],
                    'max_export_batch_size' => $config['batch']['max_export_batch_size'],
                    'auto_flush' => $config['batch']['auto_flush'],
                    'meter_provider' => isset($config['batch']['meter_provider']) ? new Reference($config['batch']['meter_provider']) : null,
                ] : null,
                isset($config['exporter']) ? new Reference($config['exporter']) : null,
            ]);
    }

    /**
     * @param array{
     *     type: string,
     *     processor?: string,
     * } $config
     */
    private function loadLogProvider(string $name, array $config): void
    {
        $this->container
            ->setDefinition(
                sprintf('open_telemetry.logs.providers.%s', $name),
                new ChildDefinition('open_telemetry.logs.provider_interface')
            )
            ->setFactory([new Reference(sprintf('open_telemetry.logs.provider_factory.%s', $config['type'])), 'createProvider'])
            ->setArguments([
                isset($config['processor']) ? new Reference($config['processor']) : null,
                new Reference('open_telemetry.resource_info'),
            ]);
    }

    /**
     * @param array{
     *     provider: string,
     *     name?: string,
     *     version?: string,
     * } $config
     */
    private function loadLogLogger(string $name, array $config): void
    {
        $this->container
            ->setDefinition(
                sprintf('open_telemetry.logs.loggers.%s', $name),
                new ChildDefinition('open_telemetry.logs.logger_interface'),
            )
            ->setPublic(true)
            ->setFactory([new Reference($config['provider']), 'getLogger'])
            ->setArguments([
                $config['name'] ?? $this->container->getParameter('open_telemetry.bundle.name'),
                $config['version'] ?? $this->container->getParameter('open_telemetry.bundle.version'),
            ]);
    }

    private function loadMonologHandlers(): void
    {
        if (false === $this->config['monolog']['enabled']) {
            return;
        }

        if (!class_exists(Handler::class)) {
            throw new \LogicException('To configure the Monolog handler, you must first install the open-telemetry/opentelemetry-logger-monolog package.');
        }

        foreach ($this->config['monolog']['handlers'] as $name => $handler) {
            $handlerId = sprintf('open_telemetry.logs.monolog.handlers.%s', $name);
            $this->container
                ->setDefinition($handlerId, new ChildDefinition('open_telemetry.logs.monolog.handler'))
                ->setPublic(true)
                ->setArguments([
                    '$loggerProvider' => new Reference($handler['provider']),
                    '$level' => Level::fromName(ucfirst($handler['level'])),
                    '$bubble' => $handler['bubble'],
                ]);
        }
    }
}

1	<?php
2
3	namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection;
4
5	use FriendsOfOpenTelemetry\OpenTelemetryBundle\OpenTelemetry\Exporter\ExporterOptionsInterface;
6	use FriendsOfOpenTelemetry\OpenTelemetryBundle\OpenTelemetry\Log\LogProcessor\LogProcessorEnum;
7	use Monolog\Level;
8	use OpenTelemetry\API\Common\Time\ClockInterface;
9	use OpenTelemetry\Contrib\Logs\Monolog\Handler;
10	use Symfony\Component\DependencyInjection\ChildDefinition;
11	use Symfony\Component\DependencyInjection\ContainerBuilder;
12	use Symfony\Component\DependencyInjection\Reference;
13
14	/**
15	* @phpstan-import-type ExporterOptions from ExporterOptionsInterface
16	*/
17	final class OpenTelemetryLogsExtension
18	{
19	/**
20	* @var array<string, mixed>
21	*/
22	private array $config;
23	private ContainerBuilder $container;
24
25	/**
26	* @param array{
27	* monolog: array<string, mixed>,
28	* loggers: array<string, mixed>,
29	* exporters: array<string, mixed>,
30	* processors: array<string, mixed>,
31	* providers: array<string, mixed>
32	* }\|array<string, mixed> $config
33	*/
34	public function __invoke(array $config, ContainerBuilder $container): void
35	{
36	$this->config = $config;	22✔
37	$this->container = $container;	22✔
38
39	foreach ($this->config['exporters'] as $name => $exporter) {	22✔
40	$this->loadLogExporter($name, $exporter);	3✔
41	}
42
43	foreach ($this->config['processors'] as $name => $processor) {	22✔
44	$this->loadLogProcessor($name, $processor);	5✔
45	}
46
47	foreach ($this->config['providers'] as $name => $provider) {	22✔
48	$this->loadLogProvider($name, $provider);	5✔
49	}
50
51	foreach ($this->config['loggers'] as $name => $logger) {	22✔
52	$this->loadLogLogger($name, $logger);	5✔
53	}
54
55	$defaultLogger = null;	22✔
56	if (0 < count($this->config['loggers'])) {	22✔
57	$defaultLogger = array_key_first($this->config['loggers']);	5✔
58	}
59
60	if (null !== $defaultLogger) {	22✔
61	$this->container->setAlias('open_telemetry.logs.default_logger', new Reference(sprintf('open_telemetry.logs.loggers.%s', $defaultLogger)));	5✔
62	}
63
64	$this->loadMonologHandlers();	22✔
65	}
66
67	/**
68	* @param array{
69	* dsn: string,
70	* options?: ExporterOptions
71	* } $config
72	*/
73	private function loadLogExporter(string $name, array $config): void
74	{
75	$dsn = (new ChildDefinition('open_telemetry.exporter_dsn'))->setArguments([$config['dsn']]);	3✔
76	$exporterOptions = (new ChildDefinition('open_telemetry.otlp_exporter_options'))->setArguments([$config['options'] ?? []]);	3✔
77
78	$this->container	3✔
79	->setDefinition(	3✔
80	sprintf('open_telemetry.logs.exporters.%s', $name),	3✔
81	new ChildDefinition('open_telemetry.logs.exporter_interface'),	3✔
82	)	3✔
83	->setArguments([$dsn, $exporterOptions]);	3✔
84	}
85
86	/**
87	* @param array{
88	* type: string,
89	* processors?: string[],
90	* batch?: array{
91	* clock: class-string<ClockInterface>,
92	* max_queue_size: int,
93	* schedule_delay: int,
94	* export_timeout: int,
95	* max_export_batch_size: int,
96	* auto_flush: bool,
97	* meter_provider?: string,
98	* },
99	* exporter?: string
100	* } $config
101	*/
102	private function loadLogProcessor(string $name, array $config): void
103	{
104	$this->container	5✔
105	->setDefinition(	5✔
106	sprintf('open_telemetry.logs.processors.%s', $name),	5✔
107	new ChildDefinition('open_telemetry.logs.processor_interface')	5✔
108	)	5✔
109	->setFactory([new Reference(sprintf('open_telemetry.logs.processor_factory.%s', $config['type'])), 'createProcessor'])	5✔
110	->setArguments([	5✔
111	array_map(fn (string $processor) => new Reference($processor), $config['processors'] ?? []),	5✔
112	LogProcessorEnum::Batch->value === $config['type'] && isset($config['batch']) ? [	5✔
113	'clock' => new Reference($config['batch']['clock']),	5✔
114	'max_queue_size' => $config['batch']['max_queue_size'],	5✔
115	'schedule_delay' => $config['batch']['schedule_delay'],	5✔
116	'export_timeout' => $config['batch']['export_timeout'],	5✔
117	'max_export_batch_size' => $config['batch']['max_export_batch_size'],	5✔
118	'auto_flush' => $config['batch']['auto_flush'],	5✔
119	'meter_provider' => isset($config['batch']['meter_provider']) ? new Reference($config['batch']['meter_provider']) : null,	5✔
120	] : null,
121	isset($config['exporter']) ? new Reference($config['exporter']) : null,	5✔
122	]);	5✔
123	}
124
125	/**
126	* @param array{
127	* type: string,
128	* processor?: string,
129	* } $config
130	*/
131	private function loadLogProvider(string $name, array $config): void
132	{
133	$this->container	5✔
134	->setDefinition(	5✔
135	sprintf('open_telemetry.logs.providers.%s', $name),	5✔
136	new ChildDefinition('open_telemetry.logs.provider_interface')	5✔
137	)	5✔
138	->setFactory([new Reference(sprintf('open_telemetry.logs.provider_factory.%s', $config['type'])), 'createProvider'])	5✔
139	->setArguments([	5✔
140	isset($config['processor']) ? new Reference($config['processor']) : null,	5✔
141	new Reference('open_telemetry.resource_info'),	5✔
142	]);	5✔
143	}
144
145	/**
146	* @param array{
147	* provider: string,
148	* name?: string,
149	* version?: string,
150	* } $config
151	*/
152	private function loadLogLogger(string $name, array $config): void
153	{
154	$this->container	5✔
155	->setDefinition(	5✔
156	sprintf('open_telemetry.logs.loggers.%s', $name),	5✔
157	new ChildDefinition('open_telemetry.logs.logger_interface'),	5✔
158	)	5✔
159	->setPublic(true)	5✔
160	->setFactory([new Reference($config['provider']), 'getLogger'])	5✔
161	->setArguments([	5✔
162	$config['name'] ?? $this->container->getParameter('open_telemetry.bundle.name'),	5✔
163	$config['version'] ?? $this->container->getParameter('open_telemetry.bundle.version'),	5✔
164	]);	5✔
165	}
166
167	private function loadMonologHandlers(): void
168	{
169	if (false === $this->config['monolog']['enabled']) {	22✔
170	return;	21✔
171	}
172
173	if (!class_exists(Handler::class)) {	1✔
174	throw new \LogicException('To configure the Monolog handler, you must first install the open-telemetry/opentelemetry-logger-monolog package.');	×
175	}
176
177	foreach ($this->config['monolog']['handlers'] as $name => $handler) {	1✔
178	$handlerId = sprintf('open_telemetry.logs.monolog.handlers.%s', $name);	1✔
179	$this->container	1✔
180	->setDefinition($handlerId, new ChildDefinition('open_telemetry.logs.monolog.handler'))	1✔
181	->setPublic(true)	1✔
182	->setArguments([	1✔
183	'$loggerProvider' => new Reference($handler['provider']),	1✔
184	'$level' => Level::fromName(ucfirst($handler['level'])),	1✔
185	'$bubble' => $handler['bubble'],	1✔
186	]);	1✔
187	}
188	}
189	}

FriendsOfOpenTelemetry / opentelemetry-bundle / 13008726707

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