func TestHandlePrometheus(t *testing.T) {
for _, tc := range handlePrometheusTests {
ms := metrics.Store{}
for _, metric := range tc.metrics {
ms.Add(metric)
}
o := Options{&ms, "gunstar"}
e, err := New(o)
if err != nil {
t.Fatalf("couldn't make exporter: %s", err)
}
response := httptest.NewRecorder()
e.HandlePrometheusMetrics(response, &http.Request{})
if response.Code != 200 {
t.Errorf("test case %s: response code not 200: %d", tc.name, response.Code)
}
b, err := ioutil.ReadAll(response.Body)
if err != nil {
t.Errorf("test case %s: failed to read response: %s", tc.name, err)
}
diff := pretty.Compare(string(b), tc.expected)
if len(diff) > 0 {
t.Errorf("test case %s: response not expected:\n%s", tc.name, diff)
}
}
}
// Find a metric in a store
func FindMetricOrNil(store *metrics.Store, name string) *metrics.Metric {
store.RLock()
defer store.RUnlock()
for _, m := range store.Metrics {
if m.Name == name {
return m
}
}
return nil
}
func TestMetricToCollectd(t *testing.T) {
ts, terr := time.Parse("2006/01/02 15:04:05", "2012/07/24 10:14:00")
if terr != nil {
t.Errorf("time parse error: %s", terr)
}
ms := metrics.Store{}
scalarMetric := metrics.NewMetric("foo", "prog", metrics.Counter)
d, _ := scalarMetric.GetDatum()
d.Set(37, ts)
ms.Add(scalarMetric)
r := FakeSocketWrite(metricToCollectd, scalarMetric)
expected := []string{"PUTVAL \"gunstar/mtail-prog/counter-foo\" interval=60 1343124840:37\n"}
diff := pretty.Compare(r, expected)
if len(diff) > 0 {
t.Errorf("String didn't match:\n%s", diff)
}
dimensionedMetric := metrics.NewMetric("bar", "prog", metrics.Gauge, "label")
d, _ = dimensionedMetric.GetDatum("quux")
d.Set(37, ts)
d, _ = dimensionedMetric.GetDatum("snuh")
d.Set(37, ts)
ms.ClearMetrics()
ms.Add(dimensionedMetric)
r = FakeSocketWrite(metricToCollectd, dimensionedMetric)
expected = []string{
"PUTVAL \"gunstar/mtail-prog/gauge-bar-label-quux\" interval=60 1343124840:37\n",
"PUTVAL \"gunstar/mtail-prog/gauge-bar-label-snuh\" interval=60 1343124840:37\n"}
diff = pretty.Compare(r, expected)
if len(diff) > 0 {
t.Errorf("String didn't match:\n%s", diff)
}
}
func ReadTestData(file io.Reader, programfile string, store *metrics.Store) {
prog := filepath.Base(programfile)
scanner := bufio.NewScanner(file)
for scanner.Scan() {
glog.V(2).Infof("'%s'\n", scanner.Text())
match := var_re.FindStringSubmatch(scanner.Text())
glog.V(2).Infof("len match: %d\n", len(match))
if len(match) == 0 {
continue
}
var keys, vals []string
if match[3] != "" {
for _, pair := range strings.Split(match[3], ",") {
glog.V(2).Infof("pair: %s\n", pair)
kv := strings.Split(pair, "=")
keys = append(keys, kv[0])
if kv[1] != "" {
vals = append(vals, kv[1])
}
}
}
m := FindMetricOrNil(store, match[2])
if m == nil {
var kind metrics.Kind
switch match[1] {
case "counter":
kind = metrics.Counter
case "gauge":
kind = metrics.Gauge
case "timer":
kind = metrics.Timer
}
m = metrics.NewMetric(match[2], prog, kind, keys...)
glog.V(2).Infof("making a new %v\n", m)
store.Add(m)
} else {
glog.V(2).Infof("found %v\n", m)
}
if len(keys) == len(vals) {
if match[4] != "" {
val, err := strconv.ParseInt(match[4], 10, 64)
if err != nil {
glog.Fatalf("parse failed for '%s': %s", match[4], err)
}
var timestamp time.Time
glog.V(2).Infof("match 5: %q\n", match[5])
if match[5] != "" {
timestamp, _ = time.Parse(time.RFC3339, match[5])
}
glog.V(2).Infof("timestamp is %s which is %v in unix\n", timestamp.Format(time.RFC3339), timestamp.Unix())
d, err := m.GetDatum(vals...)
if err != nil {
glog.V(2).Infof("Failed to get datum: %s\n", err)
continue
}
glog.V(2).Infof("setting %v with vals %v to %v at %v\n", d, vals, val, timestamp)
d.Set(val, timestamp)
}
}
}
}