1 
#include "source/extensions/tracers/fluentd/config.h"
2 

            

        

            

                3
            

            

                
            

            

                
#include <memory>

            

        

            

                4
            

            

                
            

            

                

            

        

            

                5
            

            

                
            

            

                
#include "envoy/registry/registry.h"

            

        

            

                6
            

            

                
            

            

                

            

        

            

                7
            

            

                
            

            

                
#include "source/common/config/utility.h"

            

        

            

                8
            

            

                
            

            

                

            

        

            

                9
            

            

                
            

            

                
namespace Envoy {

            

        

            

                10
            

            

                
            

            

                
namespace Extensions {

            

        

            

                11
            

            

                
            

            

                
namespace Tracers {

            

        

            

                12
            

            

                
            

            

                
namespace Fluentd {

            

        

            

                13
            

            

                
            

            

                

            

        

            

                14
            

            

                
            

            

                
// Singleton registration via macro defined in envoy/singleton/manager.h

            

        

            

                15
            

            

                
            

            

                
SINGLETON_MANAGER_REGISTRATION(fluentd_tracer_cache);

            

        

            

                16
            

            

                
            

            

                

            

        

            

                17
            

            

                
            

            

                
FluentdTracerCacheSharedPtr FluentdTracerFactory::getTracerCacheSingleton(

            

        

            

                18
            

            

                8
            

            

                
    Server::Configuration::ServerFactoryContext& context) {

            

        

            

                19
            

            

                8
            

            

                
  return context.singletonManager().getTyped<FluentdTracerCacheImpl>(

            

        

            

                20
            

            

                8
            

            

                
      SINGLETON_MANAGER_REGISTERED_NAME(fluentd_tracer_cache),

            

        

            

                21
            

            

                8
            

            

                
      [&context] {

            

        

            

                22
            

            

                8
            

            

                
        return std::make_shared<FluentdTracerCacheImpl>(context.clusterManager(), context.scope(),

            

        

            

                23
            

            

                8
            

            

                
                                                        context.threadLocal());

            

        

            

                24
            

            

                8
            

            

                
      },

            

        

            

                25
            

            

                8
            

            

                
      /* pin = */ true);

            

        

            

                26
            

            

                8
            

            

                
}

            

        

            

                27
            

            

                
            

            

                

            

        

            

                28
            

            

                14
            

            

                
FluentdTracerFactory::FluentdTracerFactory() : FactoryBase("envoy.tracers.fluentd") {}

            

        

            

                29
            

            

                
            

            

                

            

        

            

                30
            

            

                
            

            

                
Tracing::DriverSharedPtr FluentdTracerFactory::createTracerDriverTyped(

            

        

            

                31
            

            

                
            

            

                
    const envoy::extensions::tracers::fluentd::v3::FluentdConfig& proto_config,

            

        

            

                32
            

            

                2
            

            

                
    Server::Configuration::TracerFactoryContext& context) {

            

        

            

                33
            

            

                2
            

            

                
  return std::make_shared<Driver>(std::make_shared<FluentdConfig>(proto_config), context,

            

        

            

                34
            

            

                2
            

            

                
                                  getTracerCacheSingleton(context.serverFactoryContext()));

            

        

            

                35
            

            

                2
            

            

                
}

            

        

            

                36
            

            

                
            

            

                

            

        

            

                37
            

            

                
            

            

                
/**

            

        

            

                38
            

            

                
            

            

                
 * Static registration for the Fluentd tracer. @see RegisterFactory.

            

        

            

                39
            

            

                
            

            

                
 */

            

        

            

                40
            

            

                
            

            

                
REGISTER_FACTORY(FluentdTracerFactory, Server::Configuration::TracerFactory);

            

        

            

                41
            

            

                
            

            

                

            

        

            

                42
            

            

                
            

            

                
} // namespace Fluentd

            

        

            

                43
            

            

                
            

            

                
} // namespace Tracers

            

        

            

                44
            

            

                
            

            

                
} // namespace Extensions

            

        

            

                45
            

            

                
            

            

                
} // namespace Envoy