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(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
}
func init() {
Initialize(log_sender.NewLogSender(autowire.AutowiredEmitter(), gosteno.NewLogger("autowire/logs")))
}
"time"
"github.com/cloudfoundry/loggregatorlib/loggertesthelper"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("LogSender", func() {
var (
emitter *fake.FakeEventEmitter
sender log_sender.LogSender
)
BeforeEach(func() {
emitter = fake.NewFakeEventEmitter("origin")
sender = log_sender.NewLogSender(emitter, 50*time.Millisecond, loggertesthelper.Logger())
})
AfterEach(func() {
emitter.Close()
for !emitter.IsClosed() {
time.Sleep(10 * time.Millisecond)
}
})
Describe("SendAppLog", func() {
It("sends a log message event to its emitter", func() {
err := sender.SendAppLog("app-id", "custom-log-message", "App", "0")
Expect(err).NotTo(HaveOccurred())
Expect(emitter.Messages).To(HaveLen(1))
Expect(err).ToNot(HaveOccurred())
go listenForLogs()
udpAddr := udpConn.LocalAddr().(*net.UDPAddr)
dropsonde.Initialize(fmt.Sprintf("localhost:%d", udpAddr.Port), origin...)
sender := metric_sender.NewMetricSender(dropsonde.AutowiredEmitter())
batcher := metricbatcher.New(sender, 100*time.Millisecond)
metrics.Initialize(sender, batcher)
})
AfterEach(func() {
udpConn.Close()
})
It("sends dropped error message for messages which are just under 64k and don't fit in UDP packet", func() {
logSender := log_sender.NewLogSender(dropsonde.AutowiredEmitter(), time.Second, loggertesthelper.Logger())
const length = 64*1024 - 1
reader := strings.NewReader(strings.Repeat("s", length) + "\n")
logSender.ScanErrorLogStream("someId", "app", "0", reader)
Eventually(func() []*events.LogMessage {
logLock.RLock()
defer logLock.RUnlock()
return logMessages
}).Should(HaveLen(1))
Expect(logMessages[0].MessageType).To(Equal(events.LogMessage_ERR.Enum()))
Expect(string(logMessages[0].GetMessage())).To(ContainSubstring("message could not fit in UDP packet"))
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("LogSender", func() {
var (
emitter *fake.FakeEventEmitter
sender log_sender.LogSender
)
BeforeEach(func() {
emitter = fake.NewFakeEventEmitter("origin")
metricSender := metric_sender.NewMetricSender(emitter)
batcher := metricbatcher.New(metricSender, time.Millisecond)
metrics.Initialize(metricSender, batcher)
sender = log_sender.NewLogSender(emitter, loggertesthelper.Logger())
})
AfterEach(func() {
emitter.Close()
for !emitter.IsClosed() {
time.Sleep(10 * time.Millisecond)
}
})
Describe("SendAppLog", func() {
It("sends a log message event to its emitter", func() {
err := sender.SendAppLog("app-id", "custom-log-message", "App", "0")
Expect(err).NotTo(HaveOccurred())
Expect(emitter.GetMessages()).To(HaveLen(1))