How to instrument Prometheus Gauge using OpenCensus?

Question

I am trying to find a way to instrument Prometheus Gauge metrics using OpenCencus in Golang. The goal is to track no of active sessions. So value can increase and decrease and also can reset to 0 on server restart.

They have an example of it https://opencensus.io/quickstart/go/metrics/, but I am not able to co-relate any with Gauge and resetting to 0.

Could you suggest which Measure and View I should use to instrument Gauge which can increase, decrease, and reset to 0?

Answer 1

https://opencensus.io/stats/view/

I've not tried this but LastValue may (!?) convert to a Prometheus Gauge.

Count gives you the number of measurements and yields an (increasing) Counter. So, that's not helpful for you.

The only other alternatives are Sum and Distribution.

If LastValue doesn't yield a gauge, you may need to use Distribution.

Update: LastValue == Gauge

Hacked the example that was given:

package main

import (
    "context"
    "fmt"
    "log"
    "math/rand"
    "net/http"
    "os"
    "time"

    "contrib.go.opencensus.io/exporter/prometheus"
    "go.opencensus.io/stats"
    "go.opencensus.io/stats/view"
    "go.opencensus.io/tag"
)

var (
    MLatencyMs = stats.Float64("latency", "The latency in milliseconds", "ms")
)
var (
    KeyMethod, _ = tag.NewKey("method")
)

func main() {

    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    view1 := &view.View{
        Name:        "dist",
        Measure:     MLatencyMs,
        Description: "The dist of the latencies",
        TagKeys:     []tag.Key{KeyMethod},
        Aggregation: view.Distribution(0, 10, 100, 1000, 10000, 100000),
    }

    view2 := &view.View{
        Name:        "last",
        Measure:     MLatencyMs,
        Description: "The last of the latencies",
        TagKeys:     []tag.Key{KeyMethod},
        Aggregation: view.LastValue(),
    }

    if err := view.Register(view1, view2); err != nil {
        log.Fatalf("Failed to register the views: %v", err)
    }

    pe, err := prometheus.NewExporter(prometheus.Options{
        Namespace: "distlast",
    })
    if err != nil {
        log.Fatalf("Failed to create the Prometheus stats exporter: %v", err)
    }

    go func() {
        mux := http.NewServeMux()
        mux.Handle("/metrics", pe)
        log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), mux))
    }()

    rand.Seed(time.Now().UnixNano())
    ctx := context.Background()

    for {
        n := rand.Intn(100)
        log.Printf("[loop] n=%d\n", n)
        stats.Record(ctx, MLatencyMs.M(float64(time.Duration(n))))
        time.Sleep(1 * time.Second)
    }

}

And then go run . yields:

2020/10/15 14:03:25 [loop] n=77
2020/10/15 14:03:26 [loop] n=62
2020/10/15 14:03:27 [loop] n=48
2020/10/15 14:03:28 [loop] n=76
2020/10/15 14:03:29 [loop] n=20
2020/10/15 14:03:30 [loop] n=46
2020/10/15 14:03:31 [loop] n=47
2020/10/15 14:03:32 [loop] n=64
2020/10/15 14:03:33 [loop] n=15
2020/10/15 14:03:34 [loop] n=8

And metrics on localhost:8080/metrics yields:

# HELP distlast_dist The dist of the latencies
# TYPE distlast_dist histogram
distlast_dist_bucket{method="",le="10"} 1
distlast_dist_bucket{method="",le="100"} 10
distlast_dist_bucket{method="",le="1000"} 10
distlast_dist_bucket{method="",le="10000"} 10
distlast_dist_bucket{method="",le="100000"} 10
distlast_dist_bucket{method="",le="+Inf"} 10
distlast_dist_sum{method=""} 463.00000000000006
distlast_dist_count{method=""} 10
# HELP distlast_last The last of the latencies
# TYPE distlast_last gauge
distlast_last{method=""} 8

NOTE distlast_last has a value of 8 corresponding to the n=8 and distlast_dist_sum has a value of 463.