func main() {
// Metron is intended to be light-weight so we occupy only one core
runtime.GOMAXPROCS(1)
flag.Parse()
config, logger := parseConfig(*debug, *configFilePath, *logFilePath)
dopplerClientPool := initializeClientPool(config, logger)
dopplerForwarder := dopplerforwarder.New(dopplerClientPool, logger)
byteSigner := signer.New(config.SharedSecret, dopplerForwarder)
marshaller := eventmarshaller.New(byteSigner, logger)
messageTagger := tagger.New(config.Deployment, config.Job, config.Index, marshaller)
aggregator := messageaggregator.New(messageTagger, logger)
initializeMetrics(byteSigner, config, logger)
dropsondeUnmarshaller := eventunmarshaller.New(aggregator, logger)
dropsondeReader := networkreader.New(fmt.Sprintf("localhost:%d", config.DropsondeIncomingMessagesPort), "dropsondeAgentListener", dropsondeUnmarshaller, logger)
// TODO: remove next four lines when legacy support is removed (or extracted to injector)
legacyMarshaller := eventmarshaller.New(byteSigner, logger)
legacyMessageTagger := tagger.New(config.Deployment, config.Job, config.Index, legacyMarshaller)
legacyUnmarshaller := legacyunmarshaller.New(legacyMessageTagger, logger)
legacyReader := networkreader.New(fmt.Sprintf("localhost:%d", config.LegacyIncomingMessagesPort), "legacyAgentListener", legacyUnmarshaller, logger)
go legacyReader.Start()
dropsondeReader.Start()
}
func main() {
// Metron is intended to be light-weight so we occupy only one core
runtime.GOMAXPROCS(1)
flag.Parse()
config, err := config.ParseConfig(*configFilePath)
if err != nil {
panic(err)
}
log := logger.NewLogger(*debug, *logFilePath, "metron", config.Syslog)
log.Info("Startup: Setting up the Metron agent")
dopplerClientPool, err := initializeClientPool(config, log)
if err != nil {
log.Errorf("Error while initializing client pool: %s", err.Error())
os.Exit(-1)
}
dopplerForwarder := dopplerforwarder.New(dopplerClientPool, log)
byteSigner := signer.New(config.SharedSecret, dopplerForwarder)
marshaller := eventmarshaller.New(byteSigner, log)
messageTagger := tagger.New(config.Deployment, config.Job, config.Index, marshaller)
aggregator := messageaggregator.New(messageTagger, log)
initializeMetrics(byteSigner, config, log)
dropsondeUnmarshaller := eventunmarshaller.New(aggregator, log)
dropsondeReader := networkreader.New(fmt.Sprintf("localhost:%d", config.DropsondeIncomingMessagesPort), "dropsondeAgentListener", dropsondeUnmarshaller, log)
log.Info("metron started")
dropsondeReader.Start()
}
func main() {
flag.Parse()
config, logger := parseConfig(*debug, *configFilePath, *logFilePath)
dopplerClientPool := initializeClientPool(config, logger)
dopplerForwarder := dopplerforwarder.New(dopplerClientPool, logger)
byteSigner := signer.New(config.SharedSecret, dopplerForwarder)
marshaller := eventmarshaller.New(byteSigner, logger)
varzShim := varzforwarder.New(config.Job, metricTTL, marshaller, logger)
messageTagger := tagger.New(config.Deployment, config.Job, config.Index, varzShim)
aggregator := messageaggregator.New(messageTagger, logger)
dropsondeUnmarshaller := eventunmarshaller.New(aggregator, logger)
dropsondeReader := networkreader.New(fmt.Sprintf("localhost:%d", config.DropsondeIncomingMessagesPort), "dropsondeAgentListener", dropsondeUnmarshaller, logger)
// TODO: remove next two lines when legacy support is removed (or extracted to injector)
legacyUnmarshaller := legacyunmarshaller.New(aggregator, logger)
legacyReader := networkreader.New(fmt.Sprintf("localhost:%d", config.LegacyIncomingMessagesPort), "legacyAgentListener", legacyUnmarshaller, logger)
instrumentables := []instrumentation.Instrumentable{
legacyReader,
dropsondeReader,
legacyUnmarshaller,
dropsondeUnmarshaller,
aggregator,
varzShim,
marshaller,
}
go startMonitoringEndpoints(config, instrumentables, logger)
go legacyReader.Start()
dropsondeReader.Start()
}
func initializeMetrics(byteSigner *signer.Signer, config *config.Config, logger *gosteno.Logger) {
metricsMarshaller := eventmarshaller.New(byteSigner, logger)
metricsTagger := tagger.New(config.Deployment, config.Job, config.Index, metricsMarshaller)
metricsAggregator := messageaggregator.New(metricsTagger, logger)
eventWriter := eventwriter.New("MetronAgent", metricsAggregator)
metricSender := metric_sender.NewMetricSender(eventWriter)
metricBatcher := metricbatcher.New(metricSender, time.Duration(config.MetricBatchIntervalSeconds)*time.Second)
metrics.Initialize(metricSender, metricBatcher)
}
func initializeDopplerPool(conf *config.Config, logger *gosteno.Logger) (*eventmarshaller.EventMarshaller, error) {
adapter, err := storeAdapterProvider(conf.EtcdUrls, conf.EtcdMaxConcurrentRequests)
if err != nil {
return nil, err
}
err = adapter.Connect()
if err != nil {
logger.Warnd(map[string]interface{}{
"error": err.Error(),
}, "Failed to connect to etcd")
}
var protocols []string
clientPool := make(map[string]clientreader.ClientPool)
writers := make(map[string]eventmarshaller.ByteWriter)
for _, protocol := range conf.Protocols {
proto := string(protocol)
protocols = append(protocols, proto)
switch proto {
case "udp":
udpCreator := clientpool.NewUDPClientCreator(logger)
udpWrapper := dopplerforwarder.NewUDPWrapper([]byte(conf.SharedSecret), logger)
udpPool := clientpool.NewDopplerPool(logger, udpCreator)
udpForwarder := dopplerforwarder.New(udpWrapper, udpPool, logger)
clientPool[proto] = udpPool
writers[proto] = udpForwarder
case "tcp":
tcpCreator := clientpool.NewTCPClientCreator(logger, nil)
tcpWrapper := dopplerforwarder.NewWrapper(logger, proto)
tcpPool := clientpool.NewDopplerPool(logger, tcpCreator)
tcpForwarder := dopplerforwarder.New(tcpWrapper, tcpPool, logger)
tcpBatchInterval := time.Duration(conf.TCPBatchIntervalMilliseconds) * time.Millisecond
batchWriter, err := batch.NewWriter(tcpForwarder, conf.TCPBatchSizeBytes, tcpBatchInterval, logger)
if err != nil {
return nil, err
}
clientPool[proto] = tcpPool
writers[proto] = batchWriter
case "tls":
c := conf.TLSConfig
tlsConfig, err := listeners.NewTLSConfig(c.CertFile, c.KeyFile, c.CAFile)
if err != nil {
return nil, err
}
tlsConfig.ServerName = "doppler"
tlsCreator := clientpool.NewTCPClientCreator(logger, tlsConfig)
tlsWrapper := dopplerforwarder.NewWrapper(logger, proto)
tlsPool := clientpool.NewDopplerPool(logger, tlsCreator)
tlsForwarder := dopplerforwarder.New(tlsWrapper, tlsPool, logger)
tcpBatchInterval := time.Duration(conf.TCPBatchIntervalMilliseconds) * time.Millisecond
batchWriter, err := batch.NewWriter(tlsForwarder, conf.TCPBatchSizeBytes, tcpBatchInterval, logger)
if err != nil {
return nil, err
}
clientPool[proto] = tlsPool
writers[proto] = batchWriter
}
}
finder := dopplerservice.NewFinder(adapter, conf.LoggregatorDropsondePort, protocols, conf.Zone, logger)
marshaller := eventmarshaller.New(logger)
finder.Start()
go func() {
for {
protocol := clientreader.Read(clientPool, protocols, finder.Next())
logger.Infof("Chose protocol %s from last etcd event, updating writer...", protocol)
marshaller.SetWriter(writers[protocol])
}
}()
return marshaller, nil
}
"github.com/cloudfoundry/sonde-go/events"
"github.com/gogo/protobuf/proto"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"time"
)
var _ = Describe("EventMarshaller", func() {
var (
marshaller *eventmarshaller.EventMarshaller
writer *mocks.MockByteArrayWriter
)
BeforeEach(func() {
writer = &mocks.MockByteArrayWriter{}
marshaller = eventmarshaller.New(writer, loggertesthelper.Logger())
})
It("marshals envelopes into bytes", func() {
envelope := &events.Envelope{
Origin: proto.String("fake-origin-1"),
EventType: events.Envelope_LogMessage.Enum(),
LogMessage: factories.NewLogMessage(events.LogMessage_OUT, "message", "appid", "sourceType"),
}
message, _ := proto.Marshal(envelope)
marshaller.Write(envelope)
Expect(writer.Data()).Should(HaveLen(1))
outputMessage := writer.Data()[0]
func initializeDopplerPool(conf *config.Config, batcher *metricbatcher.MetricBatcher, logger *gosteno.Logger) (*eventmarshaller.EventMarshaller, error) {
adapter, err := storeAdapterProvider(conf)
if err != nil {
return nil, err
}
backoffStrategy := retrystrategy.Exponential()
err = backoff.Connect(adapter, backoffStrategy, logger, connectionRetries)
if err != nil {
return nil, err
}
var protocols []string
clientPool := make(map[string]clientreader.ClientPool)
writers := make(map[string]eventmarshaller.BatchChainByteWriter)
ip, err := localip.LocalIP()
if err != nil {
return nil, err
}
for protocol := range conf.Protocols {
proto := string(protocol)
protocols = append(protocols, proto)
switch proto {
case "udp":
udpCreator := clientpool.NewUDPClientCreator(logger)
udpWrapper := dopplerforwarder.NewUDPWrapper([]byte(conf.SharedSecret), logger)
udpPool := clientpool.NewDopplerPool(logger, udpCreator)
udpForwarder := dopplerforwarder.New(udpWrapper, udpPool, logger)
clientPool[proto] = udpPool
writers[proto] = udpForwarder
case "tcp":
tcpCreator := clientpool.NewTCPClientCreator(logger, nil)
tcpWrapper := dopplerforwarder.NewWrapper(logger, proto)
tcpPool := clientpool.NewDopplerPool(logger, tcpCreator)
tcpForwarder := dopplerforwarder.New(tcpWrapper, tcpPool, logger)
tcpBatchInterval := time.Duration(conf.TCPBatchIntervalMilliseconds) * time.Millisecond
dropCounter := batch.NewDroppedCounter(tcpForwarder, batcher, origin, ip, conf)
batchWriter, err := batch.NewWriter(
"tcp",
tcpForwarder,
dropCounter,
conf.TCPBatchSizeBytes,
tcpBatchInterval,
logger,
)
if err != nil {
return nil, err
}
clientPool[proto] = tcpPool
writers[proto] = batchWriter
case "tls":
c := conf.TLSConfig
tlsConfig, err := listeners.NewTLSConfig(c.CertFile, c.KeyFile, c.CAFile)
if err != nil {
return nil, err
}
tlsConfig.ServerName = "doppler"
tlsCreator := clientpool.NewTCPClientCreator(logger, tlsConfig)
tlsWrapper := dopplerforwarder.NewWrapper(logger, proto)
tlsPool := clientpool.NewDopplerPool(logger, tlsCreator)
tlsForwarder := dopplerforwarder.New(tlsWrapper, tlsPool, logger)
tcpBatchInterval := time.Duration(conf.TCPBatchIntervalMilliseconds) * time.Millisecond
dropCounter := batch.NewDroppedCounter(tlsForwarder, batcher, origin, ip, conf)
batchWriter, err := batch.NewWriter(
"tls",
tlsForwarder,
dropCounter,
conf.TCPBatchSizeBytes,
tcpBatchInterval,
logger,
)
if err != nil {
return nil, err
}
clientPool[proto] = tlsPool
writers[proto] = batchWriter
}
}
finder := dopplerservice.NewFinder(adapter, conf.LoggregatorDropsondePort, conf.Protocols.Strings(), conf.Zone, logger)
finder.Start()
marshaller := eventmarshaller.New(batcher, logger)
go func() {
for {
protocol := clientreader.Read(clientPool, conf.Protocols.Strings(), finder.Next())
logger.Infof("Chose protocol %s from last etcd event, updating writer...", protocol)
marshaller.SetWriter(writers[protocol])
}
}()
return marshaller, nil
}
mockBatcher *mockEventBatcher
mockChainWriter *mockBatchChainByteWriter
mockChainer *mockBatchCounterChainer
)
BeforeEach(func() {
mockBatcher = newMockEventBatcher()
mockChainWriter = newMockBatchChainByteWriter()
mockChainer = newMockBatchCounterChainer()
testhelpers.AlwaysReturn(mockBatcher.BatchCounterOutput, mockChainer)
testhelpers.AlwaysReturn(mockChainer.SetTagOutput, mockChainer)
})
JustBeforeEach(func() {
logger := gosteno.NewLogger("TestLogger")
marshaller = eventmarshaller.New(mockBatcher, logger)
marshaller.SetWriter(mockChainWriter)
})
Describe("Write", func() {
var envelope *events.Envelope
Context("with a nil writer", func() {
BeforeEach(func() {
envelope = &events.Envelope{
Origin: proto.String("The Negative Zone"),
EventType: events.Envelope_LogMessage.Enum(),
}
})
JustBeforeEach(func() {
var _ = Describe("EventMarhsaller", func() {
var (
marshaller *eventmarshaller.EventMarshaller
sender *fake.FakeMetricSender
writer *mockByteWriter
)
BeforeEach(func() {
writer = newMockByteWriter()
sender = fake.NewFakeMetricSender()
metrics.Initialize(sender, metricbatcher.New(sender, time.Millisecond*10))
})
JustBeforeEach(func() {
logger := gosteno.NewLogger("TestLogger")
marshaller = eventmarshaller.New(logger)
marshaller.SetWriter(writer)
})
Describe("Write", func() {
var envelope *events.Envelope
Context("with a nil writer", func() {
BeforeEach(func() {
envelope = &events.Envelope{
Origin: proto.String("The Negative Zone"),
EventType: events.Envelope_LogMessage.Enum(),
}
})
JustBeforeEach(func() {