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() {
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 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() {
// 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(fmt.Errorf("Unable to parse config: %s", err))
}
localIp, err := localip.LocalIP()
if err != nil {
panic(fmt.Errorf("Unable to resolve own IP address: %s", err))
}
log := logger.NewLogger(*debug, *logFilePath, "metron", config.Syslog)
go func() {
err := http.ListenAndServe(net.JoinHostPort(localIp, pprofPort), nil)
if err != nil {
log.Errorf("Error starting pprof server: %s", err.Error())
}
}()
log.Info("Startup: Setting up the Metron agent")
marshaller, err := initializeDopplerPool(config, log)
if err != nil {
panic(fmt.Errorf("Could not initialize doppler connection pool: %s", err))
}
messageTagger := tagger.New(config.Deployment, config.Job, config.Index, marshaller)
aggregator := messageaggregator.New(messageTagger, log)
statsStopChan := make(chan struct{})
initializeMetrics(messageTagger, config, statsStopChan, log)
dropsondeUnmarshaller := eventunmarshaller.New(aggregator, log)
metronAddress := fmt.Sprintf("127.0.0.1:%d", config.IncomingUDPPort)
dropsondeReader, err := networkreader.New(metronAddress, "dropsondeAgentListener", dropsondeUnmarshaller, log)
if err != nil {
panic(fmt.Errorf("Failed to listen on %s: %s", metronAddress, err))
}
log.Info("metron started")
go dropsondeReader.Start()
dumpChan := signalmanager.RegisterGoRoutineDumpSignalChannel()
killChan := signalmanager.RegisterKillSignalChannel()
for {
select {
case <-dumpChan:
signalmanager.DumpGoRoutine()
case <-killChan:
log.Info("Shutting down")
close(statsStopChan)
return
}
}
}
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 := initializeDopplerPool(config, log)
if err != nil {
log.Errorf("Failed to initialize the doppler pool: %s", err.Error())
os.Exit(-1)
}
dopplerForwarder := dopplerforwarder.New(dopplerClientPool, []byte(config.SharedSecret), uint(config.BufferSize), log)
messageTagger := tagger.New(config.Deployment, config.Job, config.Index, dopplerForwarder)
aggregator := messageaggregator.New(messageTagger, log)
initializeMetrics(messageTagger, config, log)
dropsondeUnmarshaller := eventunmarshaller.New(aggregator, log)
metronAddress := fmt.Sprintf("127.0.0.1:%d", config.DropsondeIncomingMessagesPort)
dropsondeReader, err := networkreader.New(metronAddress, "dropsondeAgentListener", dropsondeUnmarshaller, log)
if err != nil {
log.Errorf("Failed to listen on %s: %s", metronAddress, err)
os.Exit(1)
}
log.Info("metron started")
go dopplerForwarder.Run()
dropsondeReader.Start()
dopplerForwarder.Stop()
}
"sync/atomic"
"github.com/apoydence/eachers/testhelpers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/cloudfoundry/loggregatorlib/loggertesthelper"
)
var _ = Describe("Monitor", func() {
It("sends uptime metrics", func() {
logger := loggertesthelper.Logger()
writer := &fakeWriter{}
mockBatcher := newMockEventBatcher()
mockChainer := newMockBatchCounterChainer()
testhelpers.AlwaysReturn(mockBatcher.BatchCounterOutput, mockChainer)
testhelpers.AlwaysReturn(mockChainer.SetTagOutput, mockChainer)
var err error
dropsondeUnmarshaller := eventunmarshaller.New(writer, mockBatcher, logger)
dropsondeReader, err := networkreader.New("127.0.0.1:37474", "dropsondeAgentListener", dropsondeUnmarshaller, logger)
Expect(err).NotTo(HaveOccurred())
go dropsondeReader.Start()
defer dropsondeReader.Stop()
Eventually(func() uint64 { return atomic.LoadUint64(&writer.lastUptime) }, 3).Should(BeNumerically(">", 1))
})
})
"time"
)
var _ = Describe("NetworkReader", func() {
var reader *networkreader.NetworkReader
var readerStopped chan struct{}
var writer mocks.MockByteArrayWriter
var port int
var address string
var fakeMetricSender *fake.FakeMetricSender
BeforeEach(func() {
port = 3456 + GinkgoParallelNode()
address = net.JoinHostPort("127.0.0.1", strconv.Itoa(port))
writer = mocks.MockByteArrayWriter{}
reader = networkreader.New(address, "networkReader", &writer, loggertesthelper.Logger())
readerStopped = make(chan struct{})
})
Context("with a reader running", func() {
BeforeEach(func() {
loggertesthelper.TestLoggerSink.Clear()
fakeMetricSender = fake.NewFakeMetricSender()
metricBatcher := metricbatcher.New(fakeMetricSender, time.Millisecond)
metrics.Initialize(fakeMetricSender, metricBatcher)
go func() {
reader.Start()
close(readerStopped)
}()
func main() {
// Put os.Exit in a deferred statement so that other defers get executed prior to
// the os.Exit call.
exitCode := 0
defer func() {
os.Exit(exitCode)
}()
// 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")
profiler := profiler.New(*cpuprofile, *memprofile, 1*time.Second, log)
profiler.Profile()
defer profiler.Stop()
dopplerClientPool, err := initializeDopplerPool(config, log)
if err != nil {
log.Errorf("Failed to initialize the doppler pool: %s", err.Error())
os.Exit(-1)
}
dopplerForwarder := dopplerforwarder.New(dopplerClientPool, []byte(config.SharedSecret), uint(config.BufferSize), config.EnableBuffer, log)
messageTagger := tagger.New(config.Deployment, config.Job, config.Index, dopplerForwarder)
aggregator := messageaggregator.New(messageTagger, log)
statsStopChan := make(chan struct{})
initializeMetrics(messageTagger, config, statsStopChan, log)
dropsondeUnmarshaller := eventunmarshaller.New(aggregator, log)
metronAddress := fmt.Sprintf("127.0.0.1:%d", config.DropsondeIncomingMessagesPort)
dropsondeReader, err := networkreader.New(metronAddress, "dropsondeAgentListener", dropsondeUnmarshaller, log)
if err != nil {
log.Errorf("Failed to listen on %s: %s", metronAddress, err)
exitCode = 1
return
}
log.Info("metron started")
go dopplerForwarder.Run()
go dropsondeReader.Start()
dumpChan := signalmanager.RegisterGoRoutineDumpSignalChannel()
killChan := signalmanager.RegisterKillSignalChannel()
for {
select {
case <-dumpChan:
signalmanager.DumpGoRoutine()
case <-killChan:
log.Info("Shutting down")
dopplerForwarder.Stop()
close(statsStopChan)
return
}
}
}
import (
"github.com/cloudfoundry/loggregatorlib/loggertesthelper"
"github.com/cloudfoundry/sonde-go/events"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"metron/networkreader"
"metron/writers/eventunmarshaller"
"sync/atomic"
)
var _ = Describe("Monitor", func() {
It("sends uptime metrics", func() {
logger := loggertesthelper.Logger()
writer := &fakeWriter{}
dropsondeUnmarshaller := eventunmarshaller.New(writer, logger)
dropsondeReader := networkreader.New("localhost:37474", "dropsondeAgentListener", dropsondeUnmarshaller, logger)
go dropsondeReader.Start()
defer dropsondeReader.Stop()
Eventually(func() uint64 { return atomic.LoadUint64(&writer.lastUptime) }, 3).Should(BeNumerically(">", 1))
})
})
type fakeWriter struct {
lastUptime uint64
}
func (f *fakeWriter) Write(message *events.Envelope) {
if message.GetEventType() == events.Envelope_ValueMetric && message.GetValueMetric().GetName() == "Uptime" {
atomic.StoreUint64(&f.lastUptime, uint64(message.GetValueMetric().GetValue()))
"fmt"
"net"
"metron/networkreader"
"metron/writers/mocks"
"github.com/cloudfoundry/loggregatorlib/loggertesthelper"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("NetworkReader", func() {
Context("without a running listener", func() {
It("Emit returns a context with the given name", func() {
reader := networkreader.New("127.0.0.1:3456", "secretEventOrange", &mocks.MockByteArrayWriter{}, loggertesthelper.Logger())
context := reader.Emit()
Expect(context.Name).To(Equal("secretEventOrange"))
})
})
Context("with a reader running", func() {
var reader *networkreader.NetworkReader
var writer mocks.MockByteArrayWriter
BeforeEach(func() {
writer = mocks.MockByteArrayWriter{}
reader = networkreader.New("127.0.0.1:3456", "networkReader", &writer, loggertesthelper.Logger())
loggertesthelper.TestLoggerSink.Clear()