func (loggregatorClient *udpLoggregatorClient) Send(data []byte) {
atomic.AddUint64(&loggregatorClient.receivedMessageCount, 1)
atomic.AddUint64(&loggregatorClient.receivedByteCount, uint64(len(data)))
metrics.IncrementCounter("receivedMessageCount")
metrics.AddToCounter("receivedByteCount", uint64(len(data)))
loggregatorClient.sendChannel <- data
metrics.SendValue("currentBufferCount", float64(len(loggregatorClient.sendChannel)), "Msg")
}
func NewLoggregatorClient(loggregatorAddress string, logger generic_logger.GenericLogger, bufferSize int) LoggregatorClient {
loggregatorClient := &udpLoggregatorClient{}
la, err := net.ResolveUDPAddr("udp", loggregatorAddress)
if err != nil {
logger.Fatalf("Error resolving loggregator address %s, %s", loggregatorAddress, err)
}
connection, err := net.ListenPacket("udp", "")
if err != nil {
logger.Fatalf("Error opening udp stuff")
}
loggregatorClient.loggregatorAddress = la.IP.String()
loggregatorClient.sendChannel = make(chan []byte, bufferSize)
loggregatorClient.doneChannel = make(chan struct{})
go func() {
for dataToSend := range loggregatorClient.sendChannel {
metrics.SendValue("currentBufferCount", float64(len(loggregatorClient.sendChannel)), "Msg")
if len(dataToSend) > 0 {
writeCount, err := connection.WriteTo(dataToSend, la)
if err != nil {
logger.Errorf("Writing to loggregator %s failed %s", loggregatorAddress, err)
continue
}
logger.Debugf("Wrote %d bytes to %s", writeCount, loggregatorAddress)
atomic.AddUint64(&loggregatorClient.sentMessageCount, 1)
atomic.AddUint64(&loggregatorClient.sentByteCount, uint64(writeCount))
metrics.IncrementCounter("sentMessageCount")
metrics.AddToCounter("sentByteCount", uint64(writeCount))
} else {
logger.Debugf("Skipped writing of 0 byte message to %s", loggregatorAddress)
}
}
close(loggregatorClient.doneChannel)
}()
return loggregatorClient
}
defer lock.Unlock()
receivedEvents[eventId] = true
}()
}
}()
httpListener, err := net.Listen("tcp", "localhost:0")
Expect(err).ToNot(HaveOccurred())
defer httpListener.Close()
httpHandler := autowire.InstrumentedHandler(FakeHandler{})
go http.Serve(httpListener, httpHandler)
_, err = http.Get("http://" + httpListener.Addr().String())
Expect(err).ToNot(HaveOccurred())
metrics.SendValue("TestMetric", 0, "")
metrics.IncrementCounter("TestIncrementCounter")
expectedEventTypes := []string{"HttpStartClient", "HttpStartServer", "HttpStopServer", "HttpStopClient", "ValueMetricnumCPUS", "ValueMetricTestMetric", "CounterEventTestIncrementCounter"}
for _, eventType := range expectedEventTypes {
Eventually(func() bool {
lock.RLock()
defer lock.RUnlock()
_, ok := receivedEvents[eventType]
return ok
}).Should(BeTrue(), fmt.Sprintf("missing %s", eventType))
}
Eventually(func() bool {
lock.RLock()
"github.com/cloudfoundry/dropsonde/metric_sender/fake"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Metrics", func() {
var fakeMetricSender *fake.FakeMetricSender
BeforeEach(func() {
fakeMetricSender = fake.NewFakeMetricSender()
metrics.Initialize(fakeMetricSender)
})
It("delegates SendValue", func() {
metrics.SendValue("metric", 42.42, "answers")
Expect(fakeMetricSender.GetValue("metric").Value).To(Equal(42.42))
Expect(fakeMetricSender.GetValue("metric").Unit).To(Equal("answers"))
})
It("delegates IncrementCounter", func() {
metrics.IncrementCounter("count")
Expect(fakeMetricSender.GetCounter("count")).To(BeEquivalentTo(1))
metrics.IncrementCounter("count")
Expect(fakeMetricSender.GetCounter("count")).To(BeEquivalentTo(2))
})