// Initialize creates default emitters and instruments the default HTTP
// transport.
//
// The DROPSONDE_ORIGIN environment variable is required and specifies the
// source name for all metrics emitted by this process. If it is not set, the
// program will run normally but will not emit metrics.
//
// The DROPSONDE_DESTINATION environment variable sets the host and port to
// which metrics are sent. It is optional, and defaults to DefaultDestination.
func Initialize() {
http.DefaultTransport = &http.Transport{Proxy: http.ProxyFromEnvironment}
autowiredEmitter = &nullEventEmitter{}
origin := os.Getenv("DROPSONDE_ORIGIN")
if len(origin) == 0 {
log.Println("Failed to auto-initialize dropsonde: DROPSONDE_ORIGIN environment variable not set")
return
}
destination = os.Getenv("DROPSONDE_DESTINATION")
if len(destination) == 0 {
log.Println("DROPSONDE_DESTINATION not set. Using " + DefaultDestination)
destination = DefaultDestination
}
udpEmitter, err := emitter.NewUdpEmitter(destination)
if err != nil {
log.Printf("Failed to auto-initialize dropsonde: %v\n", err)
return
}
hbEmitter, err := emitter.NewHeartbeatEmitter(udpEmitter, origin)
if err != nil {
log.Printf("Failed to auto-initialize dropsonde: %v\n", err)
return
}
autowiredEmitter = emitter.NewEventEmitter(hbEmitter, origin)
go runtime_stats.NewRuntimeStats(autowiredEmitter, runtimeStatsInterval).Run(nil)
http.DefaultTransport = InstrumentedRoundTripper(http.DefaultTransport)
}
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(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)
}
// Initialize creates default emitters and instruments the default HTTP
// transport.
//
// The DROPSONDE_ORIGIN environment variable is required and specifies the
// source name for all metrics emitted by this process. If it is not set, the
// program will run normally but will not emit metrics.
//
// The DROPSONDE_DESTINATION environment variable sets the host and port to
// which metrics are sent. It is optional, and defaults to DefaultDestination.
func Initialize(emitter emitter.EventEmitter) {
http.DefaultTransport = &http.Transport{Proxy: http.ProxyFromEnvironment}
if emitter == nil {
autowiredEmitter = &nullEventEmitter{}
return
}
autowiredEmitter = emitter
go runtime_stats.NewRuntimeStats(autowiredEmitter, runtimeStatsInterval).Run(nil)
http.DefaultTransport = InstrumentedRoundTripper(http.DefaultTransport)
}
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
}
"github.com/cloudfoundry/sonde-go/events"
"github.com/gogo/protobuf/proto"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("RuntimeStats", func() {
var (
fakeEventEmitter *fake.FakeEventEmitter
runtimeStats *runtime_stats.RuntimeStats
stopChan, runDone chan struct{}
)
BeforeEach(func() {
fakeEventEmitter = fake.NewFakeEventEmitter("fake-origin")
runtimeStats = runtime_stats.NewRuntimeStats(fakeEventEmitter, 10*time.Millisecond)
stopChan = make(chan struct{})
runDone = make(chan struct{})
})
AfterEach(func() {
close(stopChan)
Eventually(runDone).Should(BeClosed())
})
var perform = func() {
go func() {
runtimeStats.Run(stopChan)
close(runDone)
}()
}