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
}
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)
}()
expectedLog := fmt.Sprintf("Listening on port %s", address)
Eventually(loggertesthelper.TestLoggerSink.LogContents).Should(ContainSubstring(expectedLog))
})
AfterEach(func() {
reader.Stop()
<-readerStopped
})
)
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() {
uptimeMonitor.Stop()
var _ = Describe("Batch Writer", func() {
var (
byteWriter *mockByteWriter
messageBytes []byte
prefixedMessage []byte
batcher *batch.Writer
timeout time.Duration
logger *gosteno.Logger
sender *fake.FakeMetricSender
constructorErr error
)
BeforeEach(func() {
sender = fake.NewFakeMetricSender()
metrics.Initialize(sender, metricbatcher.New(sender, time.Millisecond*10))
byteWriter = newMockByteWriter()
close(byteWriter.WriteOutput.err)
messageBytes = []byte("this is a log message")
timeout = time.Second / 2
bufferSize = 1024
logger = loggertesthelper.Logger()
// zero out the values that are assigned in the JustBeforeEach
prefixedMessage = nil
batcher = nil
constructorErr = nil
})
JustBeforeEach(func() {
prefixedMessage = prefixWithLength(messageBytes)
"github.com/cloudfoundry/dropsonde/metrics"
"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")
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())
var _ = Describe("DropsondeMarshaller", func() {
var (
inputChan chan *events.Envelope
outputChan chan []byte
runComplete chan struct{}
marshaller dropsonde_marshaller.DropsondeMarshaller
fakeSender *fake.FakeMetricSender
)
BeforeEach(func() {
inputChan = make(chan *events.Envelope, 100)
outputChan = make(chan []byte, 10)
runComplete = make(chan struct{})
marshaller = dropsonde_marshaller.NewDropsondeMarshaller(loggertesthelper.Logger())
fakeSender = fake.NewFakeMetricSender()
batcher := metricbatcher.New(fakeSender, 200*time.Millisecond)
metrics.Initialize(fakeSender, batcher)
go func() {
marshaller.Run(inputChan, outputChan)
close(runComplete)
}()
})
AfterEach(func() {
close(inputChan)
Eventually(runComplete).Should(BeClosed())
})
It("marshals envelopes into bytes", func() {
envelope := &events.Envelope{
"github.com/cloudfoundry/dropsonde/metrics"
"github.com/cloudfoundry/sonde-go/events"
"github.com/gogo/protobuf/proto"
"github.com/gorilla/websocket"
)
func TestWebsocketServer(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "WebsocketServer Suite")
}
var fakeMetricSender *fake.FakeMetricSender
var _ = BeforeSuite(func() {
fakeMetricSender = fake.NewFakeMetricSender()
metrics.Initialize(fakeMetricSender, metricbatcher.New(fakeMetricSender, 10*time.Millisecond))
})
func AddSlowWSSink(receivedChan chan []byte, errChan chan error, timeout time.Duration, url string) {
ws, _, err := websocket.DefaultDialer.Dial(url, http.Header{})
if err != nil {
panic(err)
}
go func() {
time.Sleep(timeout)
_, reader, err := ws.NextReader()
if err != nil {
errChan <- err
return
}
"github.com/cloudfoundry/dropsonde/metrics"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Deadlock", func() {
var (
metricBatcher *metricbatcher.MetricBatcher
done chan struct{}
)
BeforeEach(func() {
done = make(chan struct{})
metricSender := NewFakeMetricSender(&done)
metricBatcher = metricbatcher.New(metricSender, 50*time.Millisecond)
metrics.Initialize(metricSender, metricBatcher)
})
It("doesn't deadlock when Batch functions are called while batch sending", func() {
metricBatcher.BatchAddCounter("count1", 2)
Eventually(done).Should(BeClosed())
}, 1)
})
type FakeMetricSender struct {
done *chan struct{}
}
func NewFakeMetricSender(done *chan struct{}) *FakeMetricSender {
return &FakeMetricSender{