Fix: logger injection to callable

CHANGELOG.md

@@ -6,9 +6,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Fixed
+
+- Inject logger to callable instances. 
+
 ## [4.1.1] - 2025-03-21
 
-## Fixed
+### Fixed
 - Inject NullLogger to LoggerAwareInterface services, when logger is not set in container 
 
 ## [4.1.0] - 2025-03-15

src/Injector.php

@@ -85,16 +85,7 @@ public function createInstance($class): object
         $instance = new $class(...$constructorParams);
 
         if ($this->isLoggerInjectionRequired($instance)) {
-            if(array_key_exists($class, $this->loggersMap)) {
-                $logger = $this->loggersMap[$class];
-                if(!$logger instanceof LoggerInterface && is_callable($logger)) {
-                    $logger = $logger($this);
-                }
-            } else {
-                $logger = $this->has(LoggerInterface::class) ? $this->getService(LoggerInterface::class) : new NullLogger();
-            }
-
-            $instance->setLogger($logger);
+            $this->handleLoggerInjection($class, $instance);
         }
 
         return $instance;
@@ -130,6 +121,14 @@ public function getService(string $type): object
         } elseif ($service instanceof CallableBeanContainer) {
             $this->loggerHelper->logLazyLoading($type, $service);
             $service = $service();
+
+            if ($this->isLoggerInjectionRequired($service)) {
+                $class = get_class($service);
+                $this->handleLoggerInjection($class, $service);
+            }
+
+
+
             $this->setService($type, $service);
         }
 
@@ -229,5 +228,19 @@ private function isLoggerInjectionRequired(object $instance): bool
     {
         return $instance instanceof LoggerAwareInterface && $this->enableLoggerAwareInjection;
     }
+
+    private function handleLoggerInjection(string $class, $service): void
+    {
+        if (array_key_exists($class, $this->loggersMap)) {
+            $logger = $this->loggersMap[$class];
+            if (!$logger instanceof LoggerInterface && is_callable($logger)) {
+                $logger = $logger($this);
+            }
+        } else {
+            $logger = $this->has(LoggerInterface::class) ? $this->getService(LoggerInterface::class) : new NullLogger();
+        }
+
+        $service->setLogger($logger);
+    }
 }
 

tests/Fixture/LoggerExtendedSomeImpl.php

@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace Fixture;
+
+use Psr\Log\LoggerAwareInterface;
+use Psr\Log\LoggerAwareTrait;
+use Psr\Log\LoggerInterface;
+
+class LoggerExtendedSomeImpl implements SomeInterface, LoggerAwareInterface
+{
+    use LoggerAwareTrait;
+
+    public function getLogger(): LoggerInterface
+    {
+        return $this->logger;
+    }
+}

tests/Fixture/SomeInterface.php

@@ -0,0 +1,9 @@
+<?php
+declare(strict_types=1);
+
+namespace Fixture;
+
+interface SomeInterface
+{
+
+}

tests/InjectorBuilderTest.php

@@ -8,6 +8,8 @@
 use Fixture\ClassWithDefaultConstructorArgValue;
 use Fixture\Foo;
 use Fixture\LoggerAwareClass;
+use Fixture\LoggerExtendedSomeImpl;
+use Fixture\SomeInterface;
 use Psr\Container\ContainerInterface;
 use Psr\Log\NullLogger;
 
@@ -42,18 +44,24 @@ function (ContainerInterface $container, int $value): ClassWithDefaultConstructo
                 Bar::class                                 => function () use ($bar2) {
                     return $bar2;
                 },
+                SomeInterface::class => fn() => new LoggerExtendedSomeImpl(),
             ],
             'loggers'   => [
                 LoggerAwareClass::class        => new NullLogger(),
                 AnotherLoggerAwareClass::class => new NullLogger(),
+                LoggerExtendedSomeImpl::class => $someImplLogger = new NullLogger(),
             ],
         ]);
 
+        $injector->enableLoggerAwareInjection();
+
         $this->assertSame($bar2, $injector->getService(Bar::class));
         $this->assertInstanceOf(Foo::class, $injector->createInstance(Foo::class));
         $this->assertSame($anotherServiceInstance, $injector->getService(AnotherService::class));
         $this->assertSame(9000, $injector->get(ClassWithDefaultConstructorArgValue::class)->getValue());
 
-        $this->assertCount(2, $injector->getLoggersMap());
+        $this->assertSame($someImplLogger, $injector->getService(SomeInterface::class)->getLogger());
+
+        $this->assertCount(3, $injector->getLoggersMap());
     }
 }

tests/InjectorTest.php

@@ -13,6 +13,8 @@
 use Fixture\DefaultAnotherServiceImpl;
 use Fixture\Foo;
 use Fixture\LoggerAwareClass;
+use Fixture\LoggerExtendedSomeImpl;
+use Fixture\SomeInterface;
 use Fixture\SomeService;
 use Fixture\SomeServiceInterface;
 use FreeElephants\DI\Exception\InvalidArgumentException;
@@ -261,6 +263,23 @@ public function testLoggerMap()
         $this->assertSame($anotherLogger, $anotherLoggerAwareInstance->getLogger());
     }
 
+    public function testLoggerMapPolymorohic(): void
+    {
+        $logger = new NullLogger();
+
+        $injector = new Injector();
+        $injector->allowInstantiateNotRegisteredTypes(true);
+        $injector->enableLoggerAwareInjection();
+        $injector->registerService(LoggerExtendedSomeImpl::class, SomeInterface::class);
+        $injector->setLoggersMap([
+            LoggerExtendedSomeImpl::class        => $logger,
+        ]);
+
+        $loggerAwareImple = $injector->get(SomeInterface::class);
+
+        $this->assertSame($logger, $loggerAwareImple->getLogger());
+    }
+
     public function testHandleInstantiateInterfaceError()
     {
         $injector = new Injector();