Add support for configuring Gelf encoders in Monolog configuration

DependencyInjection/Configuration.php

@@ -50,7 +50,12 @@
  *   - [bubble]: bool, defaults to true
  *
  * - gelf:
- *   - publisher: {id: ...} or {hostname: ..., port: ..., chunk_size: ...}
+ *   - publiser:
+ *      - id: string, service id of a publisher implementation, optional if hostname is given
+ *      - hostname: string, optional if id is given
+ *      - [port]: int, defaults to 12201
+ *      - [chunk_size]: int, defaults to 1420
+ *      - [encoder]: string, its value can be 'json' or 'compressed_json'
  *   - [level]: level name or int value, defaults to DEBUG
  *   - [bubble]: bool, defaults to true
  *
@@ -816,6 +821,7 @@ private function addGelfSection(ArrayNodeDefinition $handerNode)
                         ->scalarNode('hostname')->end()
                         ->scalarNode('port')->defaultValue(12201)->end()
                         ->scalarNode('chunk_size')->defaultValue(1420)->end()
+                        ->scalarNode('encoder')->end()
                     ->end()
                     ->validate()
                         ->ifTrue(function ($v) {

DependencyInjection/MonologExtension.php

@@ -24,6 +24,7 @@
 use Symfony\Bridge\Monolog\Processor\SwitchUserTokenProcessor;
 use Symfony\Bridge\Monolog\Processor\TokenProcessor;
 use Symfony\Bridge\Monolog\Processor\WebProcessor;
+use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\Argument\BoundArgument;
 use Symfony\Component\DependencyInjection\ChildDefinition;
@@ -227,10 +228,28 @@ private function buildHandler(ContainerBuilder $container, $name, array $handler
                     ]);
                     $transport->setPublic(false);
 
+                    if (isset($handler['publisher']['encoder'])) {
+                        if ('compressed_json' === $handler['publisher']['encoder']) {
+                            $encoderClass = 'Gelf\Encoder\CompressedJsonEncoder';
+                        } elseif ('json' === $handler['publisher']['encoder']) {
+                            $encoderClass = 'Gelf\Encoder\JsonEncoder';
+                        } else {
+                            throw new InvalidConfigurationException('The gelf message encoder must be either "compressed_json" or "json".');
+                        }
+
+                        $encoder = new Definition($encoderClass);
+                        $encoder->setPublic(false);
+
+                        $transport->addMethodCall('setMessageEncoder', [$encoder]);
+                    }
+
                     $publisher = new Definition('Gelf\Publisher', []);
                     $publisher->addMethodCall('addTransport', [$transport]);
                     $publisher->setPublic(false);
                 } elseif (class_exists('Gelf\MessagePublisher')) {
+                    if (isset($handler['publisher']['encoder']) && 'compressed_json' !== $handler['publisher']['encoder']) {
+                        throw new InvalidConfigurationException('The Gelf\MessagePublisher publisher supports only the compressed json encoding. Omit the option to use the default encoding or use "compressed_json" as the encoder option.');
+                    }
                     $publisher = new Definition('Gelf\MessagePublisher', [
                         $handler['publisher']['hostname'],
                         $handler['publisher']['port'],

Tests/DependencyInjection/ConfigurationTest.php

@@ -110,6 +110,28 @@ public function testGelfPublisherService($publisher)
         $this->assertEquals('gelf.publisher', $config['handlers']['gelf']['publisher']['id']);
     }
 
+    public function testGelfPublisherWithEncoder(): void
+    {
+        $configs = [
+            [
+                'handlers' => [
+                    'gelf' => [
+                        'type' => 'gelf',
+                        'publisher' => [
+                            'hostname' => 'localhost',
+                            'encoder' => 'compressed_json',
+                        ],
+                    ],
+                ],
+            ],
+        ];
+
+        $config = $this->process($configs);
+
+        $this->assertEquals('localhost', $config['handlers']['gelf']['publisher']['hostname']);
+        $this->assertEquals('compressed_json', $config['handlers']['gelf']['publisher']['encoder']);
+    }
+
     public function testArrays()
     {
         $configs = [

Tests/DependencyInjection/Fixtures/DummyClassForClassExistsCheck.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\MonologBundle\Tests\DependencyInjection\Fixtures;
+
+class DummyClassForClassExistsCheck
+{
+}

Tests/DependencyInjection/MonologExtensionTest.php

@@ -22,6 +22,7 @@
 use Symfony\Bundle\MonologBundle\Tests\DependencyInjection\Fixtures\AsMonologProcessor\FooProcessor;
 use Symfony\Bundle\MonologBundle\Tests\DependencyInjection\Fixtures\AsMonologProcessor\FooProcessorWithPriority;
 use Symfony\Bundle\MonologBundle\Tests\DependencyInjection\Fixtures\AsMonologProcessor\RedeclareMethodProcessor;
+use Symfony\Bundle\MonologBundle\Tests\DependencyInjection\Fixtures\DummyClassForClassExistsCheck;
 use Symfony\Bundle\MonologBundle\Tests\DependencyInjection\Fixtures\ServiceWithChannel;
 use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
@@ -186,6 +187,97 @@ public function testExceptionWhenUsingGelfWithoutPublisherHostname()
         $loader->load([['handlers' => ['gelf' => ['type' => 'gelf', 'publisher' => []]]]], $container);
     }
 
+    public function testExceptionWhenUsingLegacyGelfImplementationWithUnsupportedEncoder(): void
+    {
+        if (!class_exists('Gelf\MessagePublisher')) {
+            class_alias(DummyClassForClassExistsCheck::class, 'Gelf\MessagePublisher');
+        }
+
+        $container = new ContainerBuilder();
+        $loader = new MonologExtension();
+
+        $this->expectException(InvalidConfigurationException::class);
+
+        $loader->load([['handlers' => ['gelf' => ['type' => 'gelf', 'publisher' => ['hostname' => 'localhost', 'encoder' => 'json']]]]], $container);
+    }
+
+    /**
+     * @dataProvider encoderOptionsProvider
+     */
+    public function testLegacyGelfImplementationEncoderOption(array $config): void
+    {
+        if (!class_exists('Gelf\MessagePublisher')) {
+            class_alias(DummyClassForClassExistsCheck::class, 'Gelf\MessagePublisher');
+        }
+
+        $container = $this->getContainer($config);
+        $this->assertTrue($container->hasDefinition('monolog.handler.gelf'));
+
+        $handler = $container->getDefinition('monolog.handler.gelf');
+        /** @var Definition $publisher */
+        $publisher = $handler->getArguments()[0];
+
+        $this->assertDICConstructorArguments($publisher, ['localhost', 12201, 1420]);
+    }
+
+    public function encoderOptionsProvider(): array
+    {
+        return [
+            [
+                [['handlers' => ['gelf' => ['type' => 'gelf', 'publisher' => ['hostname' => 'localhost', 'encoder' => 'compressed_json']]]]],
+            ],
+            [
+                [['handlers' => ['gelf' => ['type' => 'gelf', 'publisher' => ['hostname' => 'localhost']]]]],
+            ],
+        ];
+    }
+
+    public function testExceptionWhenUsingGelfWithInvalidEncoder(): void
+    {
+        if (!class_exists('Gelf\Transport\UdpTransport')) {
+            class_alias(DummyClassForClassExistsCheck::class, 'Gelf\Transport\UdpTransport');
+        }
+
+        $container = new ContainerBuilder();
+        $loader = new MonologExtension();
+
+        $this->expectException(InvalidConfigurationException::class);
+
+        $loader->load([['handlers' => ['gelf' => ['type' => 'gelf', 'publisher' => ['hostname' => 'localhost', 'encoder' => 'invalid_encoder']]]]], $container);
+    }
+
+    /**
+     * @dataProvider gelfEncoderProvider
+     */
+    public function testGelfWithEncoder($encoderValue, $expectedClass): void
+    {
+        if (!class_exists('Gelf\Transport\UdpTransport')) {
+            class_alias(DummyClassForClassExistsCheck::class, 'Gelf\Transport\UdpTransport');
+        }
+
+        $container = $this->getContainer([['handlers' => ['gelf' => ['type' => 'gelf', 'publisher' => ['hostname' => 'localhost', 'encoder' => $encoderValue]]]]]);
+        $this->assertTrue($container->hasDefinition('monolog.handler.gelf'));
+
+        $handler = $container->getDefinition('monolog.handler.gelf');
+        /** @var Definition $publisher */
+        $publisher = $handler->getArguments()[0];
+        /** @var Definition $transport */
+        $transport = $publisher->getMethodCalls()[0][1][0];
+        $encoder = $transport->getMethodCalls()[0][1][0];
+
+        $this->assertDICConstructorArguments($transport, ['localhost', 12201, 1420]);
+        $this->assertDICDefinitionClass($encoder, $expectedClass);
+        $this->assertDICConstructorArguments($handler, [$publisher, 'DEBUG', true]);
+    }
+
+    public function gelfEncoderProvider(): array
+    {
+        return [
+            ['json', 'Gelf\Encoder\JsonEncoder'],
+            ['compressed_json', 'Gelf\Encoder\CompressedJsonEncoder'],
+        ];
+    }
+
     public function testExceptionWhenUsingServiceWithoutId()
     {
         $container = new ContainerBuilder();