func TestCache(t *testing.T) { c := New() c.Add(points.OnePoint("hello.world", 42, 10)) if c.Size() != 1 { t.FailNow() } c.Add(points.OnePoint("hello.world", 15, 12)) if c.Size() != 2 { t.FailNow() } values := c.Pop() if values.Metric != "hello.world" { t.FailNow() } if len(values.Data) != 2 { t.FailNow() } if c.Size() != 0 { t.FailNow() } }
// Stat sends internal statistics to cache func (p *Whisper) Stat(metric string, value float64) { p.in <- points.OnePoint( fmt.Sprintf("%spersister.%s", p.graphPrefix, metric), value, time.Now().Unix(), ) }
// Stat sends internal statistics to cache func (rcv *UDP) Stat(metric string, value float64) { rcv.out <- points.OnePoint( fmt.Sprintf("%s%s", rcv.graphPrefix, metric), value, time.Now().Unix(), ) }
func TestStopConnectedTCP(t *testing.T) { test := newTCPTestCase(t, false) defer test.Finish() ch := test.rcvChan test.Send("hello.world 42.15 1422698155\n") time.Sleep(10 * time.Millisecond) select { case msg := <-ch: test.Eq(msg, points.OnePoint("hello.world", 42.15, 1422698155)) default: t.Fatalf("Message #0 not received") } test.receiver.Stop() test.receiver = nil time.Sleep(10 * time.Millisecond) test.Send("metric.name -72.11 1422698155\n") time.Sleep(10 * time.Millisecond) select { case <-ch: t.Fatalf("Message #0 received") default: } }
func TestThrottleChan(t *testing.T) { perSecond := 100 timestamp := time.Now().Unix() chIn := make(chan *points.Points) chOut := throttleChan(chIn, perSecond, nil) wait := time.After(time.Second) bw := 0 LOOP: for { select { case <-wait: break LOOP default: } chIn <- points.OnePoint("metric", 1, timestamp) <-chOut bw++ } close(chIn) max := float64(perSecond) * 1.05 min := float64(perSecond) * 0.95 assert.True(t, float64(bw) >= min) assert.True(t, float64(bw) <= max) }
func TestCacheCheckpoint(t *testing.T) { cache := New() cache.Start() cache.SetOutputChanSize(0) defer cache.Stop() startTime := time.Now().Unix() - 60*60 sizes := []int{1, 15, 42, 56, 22, 90, 1} for index, value := range sizes { metricName := fmt.Sprintf("metric%d", index) for i := value; i > 0; i-- { cache.In() <- points.OnePoint(metricName, float64(i), startTime+int64(i)) } } time.Sleep(100 * time.Millisecond) cache.doCheckpoint() d := <-cache.Out() if d.Metric != "metric0" { t.Fatal("wrong metric received") } systemMetrics := []string{ "carbon.cache.inputLenAfterCheckpoint", "carbon.cache.inputLenBeforeCheckpoint", "carbon.cache.checkpointTime", "carbon.cache.overflow", "carbon.cache.queries", "carbon.cache.metrics", "carbon.cache.size", } for _, metricName := range systemMetrics { d = <-cache.Out() if d.Metric != metricName { t.Fatalf("%#v != %#v", d.Metric, metricName) } } result := sizes[1:] sort.Sort(sort.Reverse(sort.IntSlice(result))) for _, size := range result { d = <-cache.Out() if len(d.Data) != size { t.Fatalf("wrong metric received. Waiting metric with %d points, received with %d", size, len(d.Data)) } } }
func TestUDP2(t *testing.T) { test := newUDPTestCase(t) defer test.Finish() test.Send("hello.world 42.15 1422698155\nmetric.name -72.11 1422698155\n") select { case msg := <-test.rcvChan: test.Eq(msg, points.OnePoint("hello.world", 42.15, 1422698155)) default: t.Fatalf("Message #0 not received") } select { case msg := <-test.rcvChan: test.Eq(msg, points.OnePoint("metric.name", -72.11, 1422698155)) default: t.Fatalf("Message #1 not received") } }
func randomPoints(num int, out chan *points.Points) { var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") var i int for i = 0; i < num; i++ { b := make([]rune, 32) for i := range b { b[i] = letters[rand.Intn(len(letters))] } metric := string(b) p := points.OnePoint(metric, rand.Float64(), rand.Int63()) out <- p } }
func TestTCP2(t *testing.T) { test := newTCPTestCase(t, false) defer test.Finish() test.Send("hello.world 42.15 1422698155\nmetric.name -72.11 1422698155\n") time.Sleep(10 * time.Millisecond) select { case msg := <-test.rcvChan: test.Eq(msg, points.OnePoint("hello.world", 42.15, 1422698155)) default: t.Fatalf("Message #0 not received") } select { case msg := <-test.rcvChan: test.Eq(msg, points.OnePoint("metric.name", -72.11, 1422698155)) default: t.Fatalf("Message #1 not received") } }
// Stat sends internal statistics to cache func (rcv *TCP) Stat(metric string, value float64) { var protocolPrefix string if rcv.isPickle { protocolPrefix = "pickle" } else { protocolPrefix = "tcp" } rcv.out <- points.OnePoint( fmt.Sprintf("%s%s.%s", rcv.graphPrefix, protocolPrefix, metric), value, time.Now().Unix(), ) }
func TestStat(t *testing.T) { fixture := Whisper{ graphPrefix: "bing.bang.", } fixture.in = make(chan *points.Points) go func() { output := <-fixture.in expected := points.OnePoint( "bing.bang.persister.foo.bar", 1.5, time.Now().Unix(), ) assert.Equal(t, output, expected) }() fixture.Stat("foo.bar", 1.5) }
func TestStat(t *testing.T) { mock := clock.NewMock() app.Clock = mock fixture := Whisper{ graphPrefix: "bing.bang.", } fixture.in = make(chan *points.Points) go func() { output := <-fixture.in expected := points.OnePoint( "bing.bang.persister.foo.bar", 1.5, 0, ) assert.Equal(t, output, expected) }() fixture.Stat("foo.bar", 1.5) }
func TestPickle(t *testing.T) { // > python // >>> import pickle, struct // >>> listOfMetricTuples = [("hello.world", (1452200952, 42))] // >>> payload = pickle.dumps(listOfMetricTuples, protocol=2) // >>> header = struct.pack("!L", len(payload)) // >>> message = header + payload // >>> print repr(message) // '\x00\x00\x00#\x80\x02]q\x00U\x0bhello.worldq\x01J\xf8\xd3\x8eVK*\x86q\x02\x86q\x03a.' test := newTCPTestCase(t, true) defer test.Finish() test.Send("\x00\x00\x00#\x80\x02]q\x00U\x0bhello.worldq\x01J\xf8\xd3\x8eVK*\x86q\x02\x86q\x03a.") time.Sleep(10 * time.Millisecond) select { case msg := <-test.rcvChan: test.Eq(msg, points.OnePoint("hello.world", 42, 1452200952)) default: t.Fatalf("Message #0 not received") } }
// stat send internal statistics of cache func (c *Cache) stat(metric string, value float64) { key := fmt.Sprintf("%scache.%s", c.graphPrefix, metric) c.Add(points.OnePoint(key, value, time.Now().Unix())) c.queue = append(c.queue, &queueItem{key, 1}) }
func TestCarbonlink(t *testing.T) { assert := assert.New(t) cache := New() cache.Start() cache.SetOutputChanSize(0) msg1 := points.OnePoint( "carbon.agents.carbon_agent_server.cache.size", 42.17, 1422797285, ) msg2 := points.OnePoint( "carbon.agents.carbon_agent_server.param.size", -42.14, 1422797267, ) msg3 := points.OnePoint( "carbon.agents.carbon_agent_server.param.size", 15, 1422795966, ) cache.In() <- msg1 cache.In() <- msg2 cache.In() <- msg3 defer cache.Stop() time.Sleep(50 * time.Millisecond) addr, err := net.ResolveTCPAddr("tcp", "localhost:0") assert.NoError(err) carbonlink := NewCarbonlinkListener(cache.Query()) defer carbonlink.Stop() assert.NoError(carbonlink.Listen(addr)) conn, err := net.Dial("tcp", carbonlink.Addr().String()) assert.NoError(err) conn.SetDeadline(time.Now().Add(time.Second)) defer conn.Close() var replyLength int32 var data []byte /* MESSAGE 1 */ _, err = conn.Write([]byte(sampleCacheQuery)) assert.NoError(err) err = binary.Read(conn, binary.BigEndian, &replyLength) assert.NoError(err) data = make([]byte, replyLength) err = binary.Read(conn, binary.BigEndian, data) assert.NoError(err) // {u'datapoints': [(1422797285, 42.17)]} assert.Equal("\x80\x02}(X\n\x00\x00\x00datapoints](J\xe5)\xceTG@E\x15\xc2\x8f\\(\xf6\x86eu.", string(data)) /* MESSAGE 2 */ _, err = conn.Write([]byte(sampleCacheQuery2)) assert.NoError(err) err = binary.Read(conn, binary.BigEndian, &replyLength) assert.NoError(err) data = make([]byte, replyLength) err = binary.Read(conn, binary.BigEndian, data) assert.NoError(err) // {u'datapoints': [(1422797267, -42.14), (1422795966, 15.0)]} assert.Equal("\x80\x02}(X\n\x00\x00\x00datapoints](J\xd3)\xceTG\xc0E\x11\xeb\x85\x1e\xb8R\x86J\xbe$\xceTG@.\x00\x00\x00\x00\x00\x00\x86eu.", string(data)) /* MESSAGE 3 */ /* Remove carbon.agents.carbon_agent_server.param.size from cache and request again */ for { c := <-cache.Out() if c.Metric == "carbon.agents.carbon_agent_server.param.size" { break } } _, err = conn.Write([]byte(sampleCacheQuery2)) assert.NoError(err) err = binary.Read(conn, binary.BigEndian, &replyLength) assert.NoError(err) data = make([]byte, replyLength) err = binary.Read(conn, binary.BigEndian, data) assert.NoError(err) assert.Equal("\x80\x02}(X\n\x00\x00\x00datapoints](eu.", string(data)) /* WRONG MESSAGE TEST */ logging.Test(func(log *bytes.Buffer) { // silent logs _, err = conn.Write([]byte("\x00\x00\x00\x05aaaaa")) assert.NoError(err) err = binary.Read(conn, binary.BigEndian, &replyLength) assert.Error(err) assert.Equal(io.EOF, err) }) }