Beispiel #1
0
func (s *metricsRecorderSuite) TestInit(c *gc.C) {
	w, err := spool.NewJSONMetricRecorder(
		spool.MetricRecorderConfig{
			SpoolDir: s.paths.GetMetricsSpoolDir(),
			Metrics:  map[string]corecharm.Metric{"pings": corecharm.Metric{}},
			CharmURL: "local:precise/wordpress",
			UnitTag:  s.unitTag,
		})
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(w, gc.NotNil)
	err = w.AddMetric("pings", "5", time.Now())
	c.Assert(err, jc.ErrorIsNil)
	err = w.Close()
	c.Assert(err, jc.ErrorIsNil)

	r, err := spool.NewJSONMetricReader(s.paths.GetMetricsSpoolDir())
	c.Assert(err, jc.ErrorIsNil)
	batches, err := r.Read()
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(batches, gc.HasLen, 1)
	batch := batches[0]
	c.Assert(batch.CharmURL, gc.Equals, "local:precise/wordpress")
	c.Assert(batch.UUID, gc.Not(gc.Equals), "")
	c.Assert(batch.Metrics, gc.HasLen, 1)
	c.Assert(batch.Metrics[0].Key, gc.Equals, "pings")
	c.Assert(batch.Metrics[0].Value, gc.Equals, "5")
	c.Assert(batch.UnitTag, gc.Equals, s.unitTag)

	err = r.Close()
	c.Assert(err, jc.ErrorIsNil)
}
Beispiel #2
0
func (s *stubMetricFactory) Recorder(declaredMetrics map[string]corecharm.Metric, charmURL, unitTag string) (spool.MetricRecorder, error) {
	s.MethodCall(s, "Recorder", declaredMetrics, charmURL, unitTag)
	config := spool.MetricRecorderConfig{
		SpoolDir: s.spoolDir,
		Metrics:  declaredMetrics,
		CharmURL: charmURL,
		UnitTag:  unitTag,
	}

	return spool.NewJSONMetricRecorder(config)
}
Beispiel #3
0
func (s *metricsReaderSuite) SetUpTest(c *gc.C) {
	s.paths = newTestPaths(c)
	s.unitTag = names.NewUnitTag("test-unit/0").String()

	var err error
	s.w, err = spool.NewJSONMetricRecorder(
		spool.MetricRecorderConfig{
			SpoolDir: s.paths.GetMetricsSpoolDir(),
			Metrics:  map[string]corecharm.Metric{"pings": corecharm.Metric{}},
			CharmURL: "local:precise/wordpress",
			UnitTag:  s.unitTag,
		})

	c.Assert(err, jc.ErrorIsNil)
	err = s.w.AddMetric("pings", "5", time.Now())
	c.Assert(err, jc.ErrorIsNil)
	err = s.w.Close()
	c.Assert(err, jc.ErrorIsNil)
}
Beispiel #4
0
func (s *metricsRecorderSuite) TestUnknownMetricKey(c *gc.C) {
	w, err := spool.NewJSONMetricRecorder(
		spool.MetricRecorderConfig{
			SpoolDir: s.paths.GetMetricsSpoolDir(),
			Metrics:  map[string]corecharm.Metric{},
			CharmURL: "local:precise/wordpress",
			UnitTag:  s.unitTag,
		})
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(w, gc.NotNil)
	err = w.AddMetric("pings", "5", time.Now())
	c.Assert(err, gc.ErrorMatches, `metric key "pings" not declared by the charm`)
	err = w.Close()
	c.Assert(err, jc.ErrorIsNil)

	r, err := spool.NewJSONMetricReader(s.paths.GetMetricsSpoolDir())
	c.Assert(err, jc.ErrorIsNil)
	batches, err := r.Read()
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(batches, gc.HasLen, 0)
}
Beispiel #5
0
func (s *metricsRecorderSuite) TestMetricValidation(c *gc.C) {
	tests := []struct {
		about         string
		key           string
		value         string
		expectedError string
	}{{
		about:         "metric not declared",
		key:           "pings",
		value:         "5",
		expectedError: `metric key "pings" not declared by the charm`,
	}, {
		about:         "non float metrics",
		key:           "pongs",
		value:         "abcd",
		expectedError: `invalid value type: expected float, got "abcd"`,
	}, {
		about:         "negative value",
		key:           "pongs",
		value:         "-5.0",
		expectedError: `invalid value: value must be greater or equal to zero, got -5.0`,
	}, {
		about:         "large value",
		key:           "pongs",
		value:         "1234567890123456789012345678901234567890",
		expectedError: `metric value is too large`,
	},
	}

	for _, test := range tests {
		w, err := spool.NewJSONMetricRecorder(
			spool.MetricRecorderConfig{
				SpoolDir: s.paths.GetMetricsSpoolDir(),
				Metrics: map[string]corecharm.Metric{
					"juju-units": corecharm.Metric{},
					"pongs": corecharm.Metric{
						Type: corecharm.MetricTypeAbsolute,
					},
				},
				CharmURL: "local:precise/wordpress",
				UnitTag:  s.unitTag,
			})
		c.Assert(err, jc.ErrorIsNil)
		c.Assert(w, gc.NotNil)

		c.Logf("running test: %s", test.about)
		err = w.AddMetric(test.key, test.value, time.Now())
		if test.expectedError != "" {
			c.Assert(err, gc.ErrorMatches, test.expectedError)
			err = w.Close()
			c.Assert(err, jc.ErrorIsNil)

			r, err := spool.NewJSONMetricReader(s.paths.GetMetricsSpoolDir())
			c.Assert(err, jc.ErrorIsNil)
			batches, err := r.Read()
			c.Assert(err, jc.ErrorIsNil)
			c.Assert(batches, gc.HasLen, 0)
		} else {
			c.Assert(err, jc.ErrorIsNil)
			err = w.Close()
			c.Assert(err, jc.ErrorIsNil)
		}
	}
}