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")