go get go.opentelemetry.io/otel \
go.opentelemetry.io/otel/metric \
go.opentelemetry.io/otel/sdk \
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc

// telemetry/metrics.go
package telemetry

import (
    "fmt"
    "context"

    "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
    "go.opentelemetry.io/otel/sdk/resource"
    "go.opentelemetry.io/otel/metric"
    semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
    metricsdk "go.opentelemetry.io/otel/sdk/metric"
)

// NewMeter creates a new metric.Meter that can create any metric reporter
// you might want to use in your application.
func NewMeter(ctx context.Context) (metric.Meter, error) {
    provider, err := newMeterProvider(ctx)
    if err != nil {
        return nil, fmt.Errorf("could not create meter provider: %w", err)
    }

    return provider.Meter("tracetest"), nil
}

// newMeterProvcider initialize the application resource, connects to the
// OpenTelemetry Collector and configures the metric poller that will be used
// to collect the metrics and send them to the OpenTelemetry Collector.
func newMeterProvider(ctx context.Context) (metric.MeterProvider, error) {
  // Interval which the metrics will be reported to the collector
    interval := 10 * time.Second

    resource, err := getResource()
  if err != nil {
    return nil, fmt.Errorf("could not get resource: %w", err)
  }

    collectorExporter, err := getOtelMetricsCollectorExporter(ctx, exporterConfig)
    if err != nil {
        return nil, fmt.Errorf("could not get collector exporter: %w", err)
    }

    periodicReader := metricsdk.NewPeriodicReader(collectorExporter,
        metricsdk.WithInterval(interval),
    )

    provider := metricsdk.NewMeterProvider(
        metricsdk.WithResource(resource),
        metricsdk.WithReader(periodicReader),
    )

    return provider, nil
}

// getResource creates the resource that describes our application.
//
// You can add any attributes to your resource and all your metrics
// will contain those attributes automatically. 
//
// There are some attributes that are very important to be added to the resource:
// 1. hostname: allows you to identify host-specific problems
// 2. version: allows you to pinpoint problems in specific versions
func getResource() (*resource.Resource, error) {
    resource, err := resource.Merge(
        resource.Default(),
        resource.NewWithAttributes(
            semconv.SchemaURL,
            semconv.ServiceNameKey.String("tracetest"),
        ),
    )
    if err != nil {
        return nil, fmt.Errorf("could not merge resources: %w", err)
  }

    return resource
}

// getOtelMetricsCollectorExporter creates a metric exporter that relies on
// an OpenTelemetry Collector running on "localhost:4317". 
func getOtelMetricsCollectorExporter(ctx context.Context) (metricsdk.Exporter, error) {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    exporter, err := otlpmetricgrpc.New(ctx,
        otlpmetricgrpc.WithEndpoint("localhost:4317"),
        otlpmetricgrpc.WithCompressor("gzip"),
        otlpmetricgrpc.WithInsecure(),
    )
    if err != nil {
        return nil, fmt.Errorf("could not create metric exporter: %w", err)
    }

    return exporter, nil
}

// main.go
package main

import (
    "context"
  "time"
  "runtime"

    "go.opentelemetry.io/otel/metric"
)

func main() {
    meter, err := telemetry.NewMeter(context.Background())
    if err != nil {
        panic(err)
  }

    go collectMachineResourceMetrics(meter)

  // your startup code here
  // ...
}

// collectMachineResourceMetrics gets some important resource usage from time 
// to time and report metrics about it:
func collectMachineResourceMetrics(meter metric.Meter) {
    period := 5 * time.Second
    ticker := time.NewTicker(period)

    var Mb uint64 = 1_048_576 // number of bytes in a MB

    for {
        select {
        case <-ticker.C:
            // This will be executed every "period" of time passes
            meter.Float64ObservableGauge(
                "process.allocated_memory",
                metric.WithFloat64Callback(
                    func(ctx context.Context, fo metric.Float64Observer) error {
                        var memStats runtime.MemStats
                        runtime.ReadMemStats(&memStats)

                        allocatedMemoryInMB := float64(memStats.Alloc) / float64(Mb)
                        fo.Observe(allocatedMemoryInMB)

                        return nil
                    }
                )
            )
        }
    }
}

// http/middleware/metrics.go
package http

import (
    "net/http"
    "go.opentelemetry.io/otel/metric"
)

// NewMetricMiddleware creates the middleware that will record all
// HTTP-related metrics.
func NewMetricMiddleware(meter metric.Meter) mux.MiddlewareFunc {
    return func(next http.Handler) http.Handler {
        durationHistogram, _ := meter.Int64Histogram("http.server.latency", metric.WithUnit("ms"))

        return &httpMetricMiddleware{
            next:                     next,
            requestDurationHistogram: durationHistogram,
        }
    }
}

// httpMetricMiddleware executes the HTTP endpoint while keeping track
// of how much time it took to execute and add some extra routing information
// to all metrics
type httpMetricMiddleware struct {
    next                     http.Handler
    requestDurationHistogram metric.Int64Histogram
}

func (m *httpMetricMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // Golang's http implementation doesn't allow us to retrieve the raw response
  // so we have to use a capturer in order to have access to any response
  // data. In this case, we want to capture the response HTTP status code.
    rw := NewStatusCodeCapturerWriter(w)

    initialTime := time.Now()
    m.next.ServeHTTP(rw, r)
    duration := time.Since(initialTime)

    route := mux.CurrentRoute(r)

    // It's important to use `route.GetPathTemplate` to get the unformated
  // path: For example, we get "/orders/{id}" instead of "/orders/2" or 
  // "/orders/1234"
    pathTemplate, _ := route.GetPathTemplate()

    metricAttributes := attribute.NewSet(
        attribute.String(semconv.AttributeHTTPRoute, pathTemplate),
        attribute.String(semconv.AttributeHTTPMethod, r.Method),
        attribute.Int(semconv.AttributeHTTPStatusCode, rw.statusCode),
    )

    m.requestDurationHistogram.Record(
        r.Context(),
        duration.Milliseconds(),
        metric.WithAttributeSet(metricAttributes),
    )
}

// NewStatusCodeCapturerWriter creates an HTTP.ResponseWriter capable of
// capture the HTTP response status code.
func NewStatusCodeCapturerWriter(w http.ResponseWriter) *responseWriter {
    return &responseWriter{w, http.StatusOK}
}

type responseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (w *responseWriter) WriteHeader(code int) {
    w.statusCode = code
    w.ResponseWriter.WriteHeader(code)
}

// main.go
package main

func main() {
    router := mux.NewRouter()
    // Your routes
    // router.HandleFunc("/", index)
    // router.HandleFunc("/orders", ordersEndpoint)

    // Add the metric middleware as the first middleware of the router
    // so it can keep track of how much time the endpoint takes to execute
    // with more precision.
    router.Use(middleware.NewMetricMiddleware(meter))

    // Add all other middlewares after this place
    // router.Use(analyticsMiddleware)
    // router.Use(authenticationMiddleware)
}

receivers:
    otlp:
        protocols:
            grpc:
            http:

processors:
      batch/metrics:
        send_batch_size: 650

exporters:
      prometheusremotewrite/grafanacloud:
                # When you set your prometheus account in Grafana cloud, you will see
        # these three variables. Just replace them or start your collector with
                # the environment variables set.
        endpoint: https://${PROMETHEUS_USER}:${PROMETHEUS_PASSWORD}@${PROMETHEUS_URL}
        tls:
          insecure: true
        # This will make your metrics to have all the attributes from the
        # resource you configured when creating the metrics provider.
        resource_to_telemetry_conversion:
          enabled: true

services:
    pipelines:
        metrics/grafana:
            receivers: [otlp]
            processors: [batch/metrics]
            exporters: [prometheusremotewrite/grafanacloud]

avg by(http_method, http_route) (http_server_latency_milliseconds_bucket{server_environment="production",http_route!=""})