feature: use psr3 telemetry bridge in telemetry bundle

- fix Path::realPath bug
- register psr loggers adapters automatically for telemetry loggers
- when no logger detected, bundle will register default logger and use
as main symfony logger

Author: norberttech

documentation/components/bridges/symfony-telemetry-bundle.md

@@ -42,7 +42,7 @@ flow_telemetry:
       static:
         cache:
           enabled: true  # Cache static attributes (default: true)
-          path: null     # Cache path (default: kernel cache dir)
+          path: null     # Cache file path (default: sys_get_temp_dir()/flow_telemetry_resource.cache)
         os:
           enabled: true  # Detect os.type, os.name, os.version, os.description
         host:
@@ -75,6 +75,12 @@ flow_telemetry:
 
 Static detectors are cached by default. Dynamic detectors run on every request/command.
 
+The cache file lives outside Symfony's cache lifecycle on purpose: building the Symfony cache
+(via `cache:warmup`) at image build time would otherwise freeze runtime-dependent attributes
+such as `host.name` or `process.pid` from the build container. Defaulting to
+`sys_get_temp_dir()` keeps the cache per-runtime and avoids that pitfall. To invalidate it,
+delete the cache file or restart the process; `cache:clear` does not touch it.
+
 Custom attributes override auto-detected values.
 
 ### Clock Configuration
@@ -660,6 +666,33 @@ flow_telemetry:
       version: '1.0.0'  # default: 'unknown'
 ```
 
+### Main Logger
+
+The bundle depends on [PSR-3 Telemetry Bridge](/documentation/components/bridges/psr3-telemetry-bridge.md) and registers a PSR-3 wrapper service for every named Telemetry logger at `flow.telemetry.<name>.logger.psr3`. This makes Flow Telemetry loggers usable as Symfony's `logger` service, removing the need for Monolog when telemetry is the only logging destination.
+
+In addition, the bundle always registers a `default` logger, meter, and tracer — `flow.telemetry.default.logger`, `flow.telemetry.default.logger.psr3`, `flow.telemetry.default.meter`, `flow.telemetry.default.tracer` — regardless of what is configured under `loggers`/`meters`/`tracers`. Defining your own `default` entry under those keys is allowed and will override the auto-default.
+
+**Options:**
+
+| Option        | Type             | Default | Description                                                                                                  |
+|---------------|------------------|---------|--------------------------------------------------------------------------------------------------------------|
+| `main_logger` | `string \| null` | `null`  | Name of a logger configured under `loggers` (or the always-available `default`) to alias as Symfony `logger` |
+
+**Behavior:**
+
+- When `main_logger` is set, the bundle aliases the Symfony `logger` service to `flow.telemetry.<main_logger>.logger.psr3`. If no logger with that name exists, container compilation fails with a clear error.
+- When `main_logger` is `null` and Symfony's `logger` service is the default `Symfony\Component\HttpKernel\Log\Logger`, the bundle automatically aliases `logger` to `flow.telemetry.default.logger.psr3`.
+- When `main_logger` is `null` and `logger` is provided by another bundle (Monolog, custom alias, etc.), the bundle leaves `logger` alone.
+
+```yaml
+flow_telemetry:
+  loggers:
+    app:
+      version: '1.0.0'
+
+  main_logger: app   # Symfony "logger" service -> flow.telemetry.app.logger.psr3
+```
+
 ## Pattern Matching
 
 Several configuration options support pattern matching for exclusion lists (paths, commands, templates, etc.).
@@ -840,6 +873,22 @@ flow_telemetry:
             transport:
               endpoint: '%env(OTEL_EXPORTER_OTLP_LOGS_ENDPOINT)%'
 
+  loggers:
+    app:
+      version: '%env(APP_VERSION)%'
+    audit:
+      version: '%env(APP_VERSION)%'
+      attributes:
+        channel: audit
+  meters:
+    business:
+      version: '%env(APP_VERSION)%'
+  tracers:
+    checkout:
+      version: '%env(APP_VERSION)%'
+
+  main_logger: app   # Symfony "logger" service -> flow.telemetry.app.logger.psr3
+
   instrumentation:
     http_kernel:
       enabled: true

src/bridge/symfony/telemetry-bundle/composer.json

@@ -16,8 +16,9 @@
     "license": "MIT",
     "require": {
         "php": "~8.3.0 || ~8.4.0 || ~8.5.0",
-        "flow-php/telemetry": "self.version",
+        "flow-php/psr3-telemetry-bridge": "self.version",
         "flow-php/symfony-http-foundation-telemetry-bridge": "self.version",
+        "flow-php/telemetry": "self.version",
         "psr/clock": "^1.0",
         "symfony/config": "^6.4 || ^7.4 || ^8.0",
         "symfony/console": "^6.4 || ^7.4 || ^8.0",

src/bridge/symfony/telemetry-bundle/src/Flow/Bridge/Symfony/TelemetryBundle/DependencyInjection/Compiler/MainLoggerPass.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Bridge\Symfony\TelemetryBundle\DependencyInjection\Compiler;
+
+use Flow\Bridge\Symfony\TelemetryBundle\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+final class MainLoggerPass implements CompilerPassInterface
+{
+    private const string SYMFONY_DEFAULT_LOGGER = 'Symfony\\Component\\HttpKernel\\Log\\Logger';
+
+    public function process(ContainerBuilder $container) : void
+    {
+        $mainLogger = $container->hasParameter('flow.telemetry.main_logger')
+            ? $container->getParameter('flow.telemetry.main_logger')
+            : null;
+
+        if ($mainLogger !== null) {
+            if (!\is_string($mainLogger) || $mainLogger === '') {
+                throw new RuntimeException('flow_telemetry.main_logger must be a non-empty string referencing a configured logger name.');
+            }
+
+            $targetId = 'flow.telemetry.' . $mainLogger . '.logger.psr3';
+
+            if (!$container->hasDefinition($targetId) && !$container->hasAlias($targetId)) {
+                throw new RuntimeException(\sprintf(
+                    'Configured main_logger "%s" does not have a registered PSR-3 wrapper service "%s". Make sure a logger with that name is configured under flow_telemetry.loggers, or use the always-available "default".',
+                    $mainLogger,
+                    $targetId,
+                ));
+            }
+
+            $container->setAlias('logger', $targetId)->setPublic(true);
+
+            return;
+        }
+
+        if ($container->hasAlias('logger')) {
+            return;
+        }
+
+        if (!$container->hasDefinition('logger')) {
+            return;
+        }
+
+        if ($container->getDefinition('logger')->getClass() !== self::SYMFONY_DEFAULT_LOGGER) {
+            return;
+        }
+
+        $container->setAlias('logger', 'flow.telemetry.default.logger.psr3')->setPublic(true);
+    }
+}

src/bridge/symfony/telemetry-bundle/src/Flow/Bridge/Symfony/TelemetryBundle/DependencyInjection/Configuration.php

@@ -34,15 +34,15 @@ public function getConfigTreeBuilder() : TreeBuilder
                                     ->addDefaultsIfNotSet()
                                     ->children()
                                         ->arrayNode('cache')
-                                            ->info('Caching configuration for static resource attributes')
+                                            ->info('File-based caching of static resource attributes. The cache file is intentionally outside Symfony\'s cache lifecycle so build-time cache:warmup does not freeze runtime-dependent attributes (host, process).')
                                             ->addDefaultsIfNotSet()
                                             ->children()
                                                 ->booleanNode('enabled')
                                                     ->info('Enable caching of static resource attributes')
                                                     ->defaultTrue()
                                                 ->end()
                                                 ->scalarNode('path')
-                                                    ->info('Cache file path (default: kernel cache dir)')
+                                                    ->info('Absolute path to the cache file. Default: sys_get_temp_dir()/flow_telemetry_resource.cache.')
                                                     ->defaultNull()
                                                 ->end()
                                             ->end()
@@ -111,6 +111,10 @@ public function getConfigTreeBuilder() : TreeBuilder
                     ->info('Custom PSR-20 clock service ID. If not provided, uses built-in SystemClock.')
                     ->defaultNull()
                 ->end()
+                ->scalarNode('main_logger')
+                    ->info('Name of the logger (matching a key under "loggers", or "default") whose PSR-3 wrapper will be aliased to Symfony\'s "logger" service. Leave null to auto-replace only when Symfony\'s default HttpKernel Logger is currently bound.')
+                    ->defaultNull()
+                ->end()
                 ->arrayNode('context_storage')
                     ->info('Context storage configuration')
                     ->addDefaultsIfNotSet()

src/bridge/symfony/telemetry-bundle/src/Flow/Bridge/Symfony/TelemetryBundle/DependencyInjection/FlowTelemetryExtension.php

@@ -4,6 +4,7 @@
 
 namespace Flow\Bridge\Symfony\TelemetryBundle\DependencyInjection;
 
+use Flow\Bridge\Psr3\Telemetry\{LogRecordConverter, TelemetryLogger};
 use Flow\Bridge\Symfony\TelemetryBundle\Exception\RuntimeException;
 use Flow\Bridge\Symfony\TelemetryBundle\Resource\Detector\SymfonyDeploymentDetector;
 use Flow\Bridge\Telemetry\OTLP\Exporter\{OTLPLogExporter, OTLPMetricExporter, OTLPSpanExporter};
@@ -66,17 +67,23 @@ public function load(array $configs, ContainerBuilder $container) : void
     {
         $loader = new PhpFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
         $configuration = new Configuration();
-        /** @var array{resource: array{detectors?: array{enabled?: bool, static?: array{cache?: array{enabled?: bool, path?: null|string}, os?: array{enabled?: bool}, host?: array{enabled?: bool}, service?: array{enabled?: bool}, deployment?: array{enabled?: bool}, environment?: array{enabled?: bool}}, dynamic?: array{process?: array{enabled?: bool}}}, custom?: array<string, mixed>}, clock_service_id?: null|string, context_storage?: array{type?: string, service_id?: null|string}, propagator?: array{type?: string, service_id?: null|string}, tracer_provider?: array<string, mixed>, meter_provider?: array<string, mixed>, logger_provider?: array<string, mixed>, instrumentation?: array{http_kernel?: array{enabled?: bool, exclude_paths?: array<array{path: string, method?: null|string}>, context_propagation?: bool}, console?: array{enabled?: bool, exclude_commands?: array<string>}, messenger?: array{enabled?: bool, context_propagation?: bool}, twig?: array{enabled?: bool, trace_templates?: bool, trace_blocks?: bool, trace_macros?: bool, exclude_templates?: array<string>}, http_client?: array{enabled?: bool, exclude_clients?: array<string>}, psr18_client?: array{enabled?: bool, exclude_clients?: array<string>}, dbal?: array{enabled?: bool, log_sql?: bool, max_sql_length?: int, exclude_connections?: array<string>}, cache?: array{enabled?: bool, exclude_pools?: array<string>}}, tracers?: array<string, array{version?: string, schema_url?: null|string, attributes?: array<string, mixed>}>, meters?: array<string, array{version?: string, schema_url?: null|string, attributes?: array<string, mixed>}>, loggers?: array<string, array{version?: string, schema_url?: null|string, attributes?: array<string, mixed>}>} $config */
+        /** @var array{resource: array{detectors?: array{enabled?: bool, static?: array{cache?: array{enabled?: bool, path?: null|string}, os?: array{enabled?: bool}, host?: array{enabled?: bool}, service?: array{enabled?: bool}, deployment?: array{enabled?: bool}, environment?: array{enabled?: bool}}, dynamic?: array{process?: array{enabled?: bool}}}, custom?: array<string, mixed>}, clock_service_id?: null|string, main_logger?: null|string, context_storage?: array{type?: string, service_id?: null|string}, propagator?: array{type?: string, service_id?: null|string}, tracer_provider?: array<string, mixed>, meter_provider?: array<string, mixed>, logger_provider?: array<string, mixed>, instrumentation?: array{http_kernel?: array{enabled?: bool, exclude_paths?: array<array{path: string, method?: null|string}>, context_propagation?: bool}, console?: array{enabled?: bool, exclude_commands?: array<string>}, messenger?: array{enabled?: bool, context_propagation?: bool}, twig?: array{enabled?: bool, trace_templates?: bool, trace_blocks?: bool, trace_macros?: bool, exclude_templates?: array<string>}, http_client?: array{enabled?: bool, exclude_clients?: array<string>}, psr18_client?: array{enabled?: bool, exclude_clients?: array<string>}, dbal?: array{enabled?: bool, log_sql?: bool, max_sql_length?: int, exclude_connections?: array<string>}, cache?: array{enabled?: bool, exclude_pools?: array<string>}}, tracers?: array<string, array{version?: string, schema_url?: null|string, attributes?: array<string, mixed>}>, meters?: array<string, array{version?: string, schema_url?: null|string, attributes?: array<string, mixed>}>, loggers?: array<string, array{version?: string, schema_url?: null|string, attributes?: array<string, mixed>}>} $config */
         $config = $this->processConfiguration($configuration, $configs);
 
+        $container->setParameter('flow.telemetry.main_logger', $config['main_logger'] ?? null);
+
+        $tracers = ($config['tracers'] ?? []) + ['default' => []];
+        $meters = ($config['meters'] ?? []) + ['default' => []];
+        $loggers = ($config['loggers'] ?? []) + ['default' => []];
+
         $this->registerGlobalServices($config, $container);
         $this->registerPropagator($config['propagator'] ?? [], $container);
         $this->registerResource($config['resource'], $container);
         $this->registerTelemetry($config, $container);
         $this->registerInstrumentation($config['instrumentation'] ?? [], $container, $loader);
-        $this->registerTracers($config['tracers'] ?? [], $container);
-        $this->registerMeters($config['meters'] ?? [], $container);
-        $this->registerLoggers($config['loggers'] ?? [], $container);
+        $this->registerTracers($tracers, $container);
+        $this->registerMeters($meters, $container);
+        $this->registerLoggers($loggers, $container);
     }
 
     /**
@@ -907,6 +914,11 @@ private function registerGlobalServices(array $config, ContainerBuilder $contain
         } else {
             $container->setDefinition('flow.telemetry.context_storage', new Definition(MemoryContextStorage::class));
         }
+
+        $container->setDefinition(
+            'flow.telemetry.psr3.log_record_converter',
+            new Definition(LogRecordConverter::class)
+        );
     }
 
     /**
@@ -986,7 +998,14 @@ private function registerLoggers(array $config, ContainerBuilder $container) : v
             }
 
             $definition->setPublic(true);
-            $container->setDefinition('flow.telemetry.' . $name . '.logger', $definition);
+            $loggerServiceId = 'flow.telemetry.' . $name . '.logger';
+            $container->setDefinition($loggerServiceId, $definition);
+
+            $psr3Definition = new Definition(TelemetryLogger::class);
+            $psr3Definition->setArgument(0, new Reference($loggerServiceId));
+            $psr3Definition->setArgument(1, new Reference('flow.telemetry.psr3.log_record_converter'));
+            $psr3Definition->setPublic(true);
+            $container->setDefinition($loggerServiceId . '.psr3', $psr3Definition);
         }
     }
 
@@ -1195,10 +1214,9 @@ private function registerResource(array $resourceConfig, ContainerBuilder $conta
         $cacheEnabled = $cacheConfig['enabled'] ?? true;
 
         if ($cacheEnabled) {
-            $cachePath = $cacheConfig['path'] ?? '%kernel.cache_dir%/flow_telemetry_resource.cache';
             $cachingDefinition = new Definition(CachingDetector::class);
             $cachingDefinition->setArgument(0, new Reference('flow.telemetry.resource.detector.static.chain'));
-            $cachingDefinition->setArgument(1, $cachePath);
+            $cachingDefinition->setArgument(1, $cacheConfig['path'] ?? null);
             $container->setDefinition('flow.telemetry.resource.detector.static', $cachingDefinition);
         } else {
             $container->setAlias('flow.telemetry.resource.detector.static', 'flow.telemetry.resource.detector.static.chain');

src/bridge/symfony/telemetry-bundle/src/Flow/Bridge/Symfony/TelemetryBundle/FlowTelemetryBundle.php

@@ -4,7 +4,8 @@
 
 namespace Flow\Bridge\Symfony\TelemetryBundle;
 
-use Flow\Bridge\Symfony\TelemetryBundle\DependencyInjection\Compiler\{CacheTelemetryPass, DBALTelemetryPass, HttpClientTelemetryPass, OTLPAvailabilityPass, Psr18ClientTelemetryPass};
+use Flow\Bridge\Symfony\TelemetryBundle\DependencyInjection\Compiler\{CacheTelemetryPass, DBALTelemetryPass, HttpClientTelemetryPass, MainLoggerPass, OTLPAvailabilityPass, Psr18ClientTelemetryPass};
+use Symfony\Component\DependencyInjection\Compiler\PassConfig;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
@@ -25,6 +26,7 @@ public function build(ContainerBuilder $container) : void
         parent::build($container);
 
         $container->addCompilerPass(new OTLPAvailabilityPass());
+        $container->addCompilerPass(new MainLoggerPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, -64);
 
         if (\interface_exists(self::HTTP_CLIENT_INTERFACE)) {
             $container->addCompilerPass(new HttpClientTelemetryPass());

src/bridge/symfony/telemetry-bundle/tests/Flow/Bridge/Symfony/TelemetryBundle/Tests/Context/SymfonyContext.php

@@ -103,5 +103,11 @@ public function shutdown() : void
         if ($filesystem->exists($logDir)) {
             $filesystem->remove($logDir);
         }
+
+        $defaultResourceCache = \sys_get_temp_dir() . '/flow_telemetry_resource.cache';
+
+        if ($filesystem->exists($defaultResourceCache)) {
+            $filesystem->remove($defaultResourceCache);
+        }
     }
 }

src/bridge/symfony/telemetry-bundle/tests/Flow/Bridge/Symfony/TelemetryBundle/Tests/Fixtures/Logger/StubLogger.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Bridge\Symfony\TelemetryBundle\Tests\Fixtures\Logger;
+
+use Psr\Log\AbstractLogger;
+
+final class StubLogger extends AbstractLogger
+{
+    /** @var array<int, array{level: mixed, message: string|\Stringable, context: array<array-key, mixed>}> */
+    public array $records = [];
+
+    /**
+     * @param array<array-key, mixed> $context
+     */
+    public function log($level, string|\Stringable $message, array $context = []) : void
+    {
+        $this->records[] = [
+            'level' => $level,
+            'message' => $message,
+            'context' => $context,
+        ];
+    }
+}

src/bridge/symfony/telemetry-bundle/tests/Flow/Bridge/Symfony/TelemetryBundle/Tests/Fixtures/TestKernel.php

@@ -121,7 +121,7 @@ protected function build(ContainerBuilder $container) : void
             public function process(ContainerBuilder $container) : void
             {
                 foreach ($container->getDefinitions() as $id => $definition) {
-                    if (\str_starts_with($id, 'flow.telemetry') || \str_ends_with($id, '.flow_telemetry') || \str_starts_with($id, 'test.')) {
+                    if (\str_starts_with($id, 'flow.telemetry') || \str_ends_with($id, '.flow_telemetry') || \str_starts_with($id, 'test.') || \str_starts_with($id, 'cache.flow_telemetry')) {
                         $definition->setPublic(true);
                     }
                 }