func initDaemon()

in cmd/tracing/daemon.go [146:223]
63 lines of code
6 McCabe index (conditional complexity)

func initDaemon(config *cfg.Config) *Daemon {
	if logFile != "" {
		var fileWriter io.Writer
		if *config.Logging.LogRotation {
			// Empty Archive path as code does not archive logs
			apath := ""
			maxSize := logRotationSize
			// Keep one rolled over log file around
			maxRolls := 1
			archiveExplode := false
			fileWriter, _ = log.NewRollingFileWriterSize(logFile, 0, apath, maxSize, maxRolls, 0, archiveExplode)
		} else {
			fileWriter, _ = log.NewFileWriter(logFile)
		}
		logger.LoadLogConfig(fileWriter, config, logLevel)
	} else {
		newWriter, _ := log.NewConsoleWriter()
		logger.LoadLogConfig(newWriter, config, logLevel)
	}
	defer log.Flush()

	log.Infof("Initializing AWS X-Ray daemon %v", cfg.Version)

	parameterConfig := cfg.ParameterConfigValue
	receiverCount = parameterConfig.ReceiverRoutines
	receiveBufferSize = parameterConfig.Socket.BufferSizeKB * 1024
	cpuProfile = os.Getenv("XRAY_DAEMON_CPU_PROFILE")
	memProfile = os.Getenv("XRAY_DAEMON_MEMORY_PROFILE")

	profiler.EnableCPUProfile(&cpuProfile)
	defer pprof.StopCPUProfile()

	var sock socketconn.SocketConn

	sock = udp.New(udpAddress)

	memoryLimit := evaluateBufferMemory(daemonProcessBufferMemoryMB)
	log.Infof("Using buffer memory limit of %v MB", memoryLimit)
	buffers, err := bufferpool.GetPoolBufferCount(memoryLimit, receiveBufferSize)
	if err != nil {
		log.Errorf("%v", err)
		os.Exit(1)
	}
	log.Infof("%v segment buffers allocated", buffers)
	bufferPool := bufferpool.Init(buffers, receiveBufferSize)
	std := ringbuffer.New(buffers, bufferPool)
	if config.Endpoint != "" {
		log.Debugf("Using Endpoint read from Config file: %s", config.Endpoint)
	}
	awsConfig, session := conn.GetAWSConfigSession(&conn.Conn{}, config, roleArn, regionFlag, noMetadata)
	log.Infof("Using region: %v", aws.StringValue(awsConfig.Region))

	log.Debugf("ARN of the AWS resource running the daemon: %v", resourceARN)
	telemetry.Init(awsConfig, session, resourceARN, noMetadata)

	// If calculated number of buffer is lower than our default, use calculated one. Otherwise, use default value.
	parameterConfig.Processor.BatchSize = util.GetMinIntValue(parameterConfig.Processor.BatchSize, buffers)

	config.Socket.TCPAddress = tcpAddress // assign final tcp address either through config file or cmd line
	// Create proxy http server
	server, err := proxy.NewServer(config, awsConfig, session)
	if err != nil {
		log.Errorf("Unable to start http proxy server: %v", err)
		os.Exit(1)
	}

	daemon := &Daemon{
		done:      make(chan bool),
		std:       std,
		pool:      bufferPool,
		count:     0,
		sock:      sock,
		server:    server,
		processor: processor.New(awsConfig, session, processorCount, std, bufferPool, parameterConfig),
	}

	return daemon
}