EventMetrics per response body

probes/http/http.go

@@ -73,8 +73,7 @@ type Probe struct {
 	// (runCnt % statsExportFrequency) == 0
 	statsExportFrequency int64
 
-	// default payload metrics that we clone from to build per-target payload
-	// metrics.
+	// parser for reading metrics from response body
 	payloadParser *payload.Parser
 }
 
@@ -168,7 +167,8 @@ func (p *Probe) Init(name string, opts *options.Options) error {
 		p.targetsUpdateFrequency = 1
 	}
 
-	parser, err := payload.NewParser(/*OutputMetricsOptions?*/, "http", p.name, metrics.Kind(defaultKind), p.l)
+	defaultKind := metrics.CUMULATIVE
+	parser, err := payload.NewParser(p.c.GetOutputMetricsOptions(), "http", p.name, metrics.Kind(defaultKind), p.l)
 	if err != nil {
 		return fmt.Errorf("error initializing payload metrics: %v", err)
 	}
@@ -235,11 +235,15 @@ func (p *Probe) doHTTPRequest(req *http.Request, result *probeResult, resultMu *
 
 	result.success++
 	result.latency.AddFloat64(latency.Seconds() / p.opts.LatencyUnit.Seconds())
-	if p.c.GetExportResponseAsMetrics() {
+	if p.c.GetExportResponseCountAsMetric() {
 		if len(respBody) <= maxResponseSizeForMetrics {
 			result.respBodies.IncKey(string(respBody))
 		}
 	}
+	if p.c.GetExportResponseAsMetrics() {
+		// Parse response body as metrics
+		result.responseMetrics = p.payloadParser.PayloadMetrics(result.responseMetrics, string(respBody), req.Host)
+	}
 }
 
 func (p *Probe) updateTargets() {
@@ -346,8 +350,6 @@ func (p *Probe) Start(ctx context.Context, dataChan chan *metrics.EventMetrics)
 				p.dataChan <- em
 
 				if p.c.GetExportResponseAsMetrics() {
-					result.responseMetrics = p.payloadParser.PayloadMetrics(result.responseMetrics, "" /*response?*/, target.Name)
-					p.opts.LogMetrics(result.responseMetrics)
 					p.dataChan <- result.responseMetrics
 				}
 			}

probes/http/http_test.go

@@ -153,21 +153,30 @@ func TestProbeVariousMethods(t *testing.T) {
 }
 
 func TestProbeWithBody(t *testing.T) {
-
-	testBody := "TestHTTPBody"
+	testBody := `TestHTTPBody "val123"`
 	testTarget := "test.com"
 	// Build the expected response code map
 	expectedMap := metrics.NewMap("resp", metrics.NewInt(0))
 	expectedMap.IncKey(testBody)
 	expected := expectedMap.String()
+	// Build the expected metrics
+	testBodyLines := strings.Split(testBody, "\n")
+	expectedMetrics := make(map[string]metrics.Value)
+	for _, line := range testBodyLines {
+		lineSplit := strings.Fields(line)
+		if len(lineSplit) == 2 {
+			expectedMetrics[lineSplit[0]], _ = metrics.ParseValueFromString(lineSplit[1])
+		}
+	}
 
 	p := &Probe{}
 	err := p.Init("http_test", &options.Options{
 		Targets:  targets.StaticTargets(testTarget),
 		Interval: 2 * time.Second,
 		ProbeConf: &configpb.ProbeConf{
-			Body:                    &testBody,
-			ExportResponseAsMetrics: proto.Bool(true),
+			Body:                        &testBody,
+			ExportResponseCountAsMetric: proto.Bool(true),
+			ExportResponseAsMetrics:     proto.Bool(true),
 		},
 	})
 
@@ -182,15 +191,37 @@ func TestProbeWithBody(t *testing.T) {
 	if got != expected {
 		t.Errorf("response map: got=%s, expected=%s", got, expected)
 	}
+	for key, val := range expectedMetrics {
+		metrics := p.results[testTarget].responseMetrics
+		if metrics != nil {
+			actualMetric := metrics.Metric(key)
+			if actualMetric != val {
+				t.Errorf("metric %s: got=%s, expected=%s", key, actualMetric, val)
+			}
+		} else {
+			t.Errorf("metric %s: not found, expected=%s", key, val)
+		}
+	}
 
-	// Probe 2nd run (we should get the same request body).
+	// Probe 2nd run (we should get the same request body)
 	p.runProbe(context.Background())
 	expectedMap.IncKey(testBody)
 	expected = expectedMap.String()
 	got = p.results[testTarget].respBodies.String()
 	if got != expected {
 		t.Errorf("response map: got=%s, expected=%s", got, expected)
 	}
+	for key, val := range expectedMetrics {
+		metrics := p.results[testTarget].responseMetrics
+		if metrics != nil {
+			actualMetric := metrics.Metric(key)
+			if actualMetric != val {
+				t.Errorf("metric %s: got=%s, expected=%s", key, actualMetric, val)
+			}
+		} else {
+			t.Errorf("metric %s: not found, expected=%s", key, val)
+		}
+	}
 }
 
 func TestMultipleTargetsMultipleRequests(t *testing.T) {

probes/http/proto/config.proto

@@ -4,7 +4,7 @@ package cloudprober.probes.http;
 
 import "github.com/google/cloudprober/metrics/payload/proto/config.proto";
 
-// Next tag: 17
+// Next tag: 18
 message ProbeConf {
   enum ProtocolType {
     HTTP = 0;
@@ -44,7 +44,7 @@ message ProbeConf {
   optional bool resolve_first = 4 [default = false];
 
   // Export response (body) count as a metric
-  optional bool export_response_as_metrics = 5 [default = false];
+  optional bool export_response_count_as_metric = 5 [default = false];
 
   // HTTP request method
   optional Method method = 7 [default = GET];
@@ -80,9 +80,9 @@ message ProbeConf {
   optional int32 requests_interval_msec = 99 [default = 25];
 
   // Output metrics options, where output is the response body returned by the
-  // http probe process, over stdout for ONCE probes, and through ProbeReply
-  // for SERVER probes. Cloudprober expects variables to be in the following
-  // format in the output:
+  // HTTP probe process. Cloudprober expects variables to be in the following
+  // format in the response body:
   // var1 value1 (for example: total_errors 589)
-  optional metrics.payload.OutputMetricsOptions output_metrics_options = 16;
+  optional bool export_response_as_metrics = 16 [default = false];
+  optional metrics.payload.OutputMetricsOptions output_metrics_options = 17;
 }