func initializeMetrics(batchIntervalMilliseconds uint) *metricbatcher.MetricBatcher { eventEmitter := dropsonde.AutowiredEmitter() metricSender := metric_sender.NewMetricSender(eventEmitter) metricBatcher := metricbatcher.New(metricSender, time.Duration(batchIntervalMilliseconds)*time.Millisecond) metrics.Initialize(metricSender, metricBatcher) return metricBatcher }
func initialize() { sender := metric_sender.NewMetricSender(AutowiredEmitter()) batcher := metricbatcher.New(sender, defaultBatchInterval) metrics.Initialize(sender, batcher) logs.Initialize(log_sender.NewLogSender(AutowiredEmitter(), statsInterval, gosteno.NewLogger("dropsonde/logs"))) go runtime_stats.NewRuntimeStats(autowiredEmitter, statsInterval).Run(nil) http.DefaultTransport = InstrumentedRoundTripper(http.DefaultTransport) }
func initializeMetrics(messageTagger *tagger.Tagger, config *config.Config, logger *gosteno.Logger) { metricsAggregator := messageaggregator.New(messageTagger, 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 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 initializeMetrics(config *config.Config, stopChan chan struct{}, logger *gosteno.Logger) (*metricbatcher.MetricBatcher, *eventwriter.EventWriter) { eventWriter := eventwriter.New(origin) metricSender := metric_sender.NewMetricSender(eventWriter) metricBatcher := metricbatcher.New(metricSender, time.Duration(config.MetricBatchIntervalMilliseconds)*time.Millisecond) metrics.Initialize(metricSender, metricBatcher) stats := runtime_stats.NewRuntimeStats(eventWriter, time.Duration(config.RuntimeStatsIntervalMilliseconds)*time.Millisecond) go stats.Run(stopChan) return metricBatcher, eventWriter }
func initializeMetrics(messageTagger *tagger.Tagger, config *config.Config, stopChan chan struct{}, logger *gosteno.Logger) { metricsAggregator := messageaggregator.New(messageTagger, logger) eventWriter := eventwriter.New("MetronAgent", metricsAggregator) metricSender := metric_sender.NewMetricSender(eventWriter) metricBatcher := metricbatcher.New(metricSender, time.Duration(config.MetricBatchIntervalMilliseconds)*time.Millisecond) metrics.Initialize(metricSender, metricBatcher) stats := runtime_stats.NewRuntimeStats(eventWriter, time.Duration(config.RuntimeStatsIntervalMilliseconds)*time.Millisecond) go stats.Run(stopChan) }
func initializeMetrics(origin, destination string) (*metricbatcher.MetricBatcher, error) { err := setupDefaultEmitter(origin, destination) if err != nil { // Legacy holdover. We would prefer to panic, rather than just throwing our metrics // away and pretending we're running fine, but for now, we just don't want to break // anything. dropsonde.DefaultEmitter = &dropsonde.NullEventEmitter{} } // Copied from dropsonde.initialize(), since we stopped using dropsonde.Initialize // but needed it to continue operating the same. sender := metric_sender.NewMetricSender(dropsonde.DefaultEmitter) batcher := metricbatcher.New(sender, defaultBatchInterval) metrics.Initialize(sender, batcher) logs.Initialize(log_sender.NewLogSender(dropsonde.DefaultEmitter, gosteno.NewLogger("dropsonde/logs"))) envelopes.Initialize(envelope_sender.NewEnvelopeSender(dropsonde.DefaultEmitter)) go runtime_stats.NewRuntimeStats(dropsonde.DefaultEmitter, statsInterval).Run(nil) http.DefaultTransport = dropsonde.InstrumentedRoundTripper(http.DefaultTransport) return batcher, err }
"os" "sync" ) // these tests need to be invoked individually from an external script, // since environment variables need to be set/unset before starting the tests var _ = Describe("Autowire End-to-End", func() { Context("with DROPSONDE_ORIGIN set", func() { var oldEnv string BeforeEach(func() { oldEnv = os.Getenv("DROPSONDE_ORIGIN") os.Setenv("DROPSONDE_ORIGIN", "test-origin") emitter, _ := autowire.CreateDefaultEmitter() autowire.Initialize(emitter) metrics.Initialize(metric_sender.NewMetricSender(autowire.AutowiredEmitter())) }) AfterEach(func() { os.Setenv("DROPSONDE_ORIGIN", oldEnv) }) It("emits HTTP client/server events and heartbeats", func() { udpListener, err := net.ListenPacket("udp4", ":3457") Expect(err).ToNot(HaveOccurred()) defer udpListener.Close() udpDataChan := make(chan []byte, 16) receivedEvents := make(map[string]bool) lock := sync.RWMutex{} origin := os.Getenv("DROPSONDE_ORIGIN")
"time" ) var ( fakeEventEmitter *fake.FakeEventEmitter uptimeMonitor monitor.Monitor ) const ( interval = 100 * time.Millisecond ) var _ = Describe("UptimeMonitor", func() { BeforeEach(func() { fakeEventEmitter = fake.NewFakeEventEmitter("MonitorTest") sender := metric_sender.NewMetricSender(fakeEventEmitter) batcher := metricbatcher.New(sender, 100*time.Millisecond) metrics.Initialize(sender, batcher) uptimeMonitor = monitor.NewUptimeMonitor(interval) go uptimeMonitor.Start() }) AfterEach(func() { fakeEventEmitter.Close() }) Context("stops automatically", func() { AfterEach(func() {
func init() { Initialize(metric_sender.NewMetricSender(autowire.AutowiredEmitter())) }
) // these tests need to be invoked individually from an external script, // since environment variables need to be set/unset before starting the tests var _ = Describe("Autowire End-to-End", func() { Context("with standard initialization", func() { origin := []string{"test-origin"} BeforeEach(func() { var err error udpListener, err = net.ListenPacket("udp4", ":3457") Expect(err).ToNot(HaveOccurred()) go listenForEvents(origin) dropsonde.Initialize("localhost:3457", origin...) sender := metric_sender.NewMetricSender(dropsonde.AutowiredEmitter()) batcher := metricbatcher.New(sender, 100*time.Millisecond) metrics.Initialize(sender, batcher) }) AfterEach(func() { udpListener.Close() }) It("emits HTTP client/server events", func() { httpListener, err := net.Listen("tcp", "localhost:0") Expect(err).ToNot(HaveOccurred()) defer httpListener.Close() httpHandler := dropsonde.InstrumentedHandler(FakeHandler{}) go http.Serve(httpListener, httpHandler)
"github.com/cloudfoundry/dropsonde/events" "github.com/cloudfoundry/dropsonde/metric_sender" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" ) var _ = Describe("MetricSender", func() { var ( emitter *fake.FakeEventEmitter sender metric_sender.MetricSender ) BeforeEach(func() { emitter = fake.NewFakeEventEmitter("origin") sender = metric_sender.NewMetricSender(emitter) }) It("sends a metric to its emitter", func() { err := sender.SendValue("metric-name", 42, "answers") Expect(err).NotTo(HaveOccurred()) Expect(emitter.GetMessages()).To(HaveLen(1)) metric := emitter.GetMessages()[0].Event.(*events.ValueMetric) Expect(metric.GetName()).To(Equal("metric-name")) Expect(metric.GetValue()).To(BeNumerically("==", 42)) Expect(metric.GetUnit()).To(Equal("answers")) }) It("returns an error if it can't send metric value", func() { emitter.ReturnError = errors.New("some error")