package main

import (
  "context"
  "log"
  "net/http"
  "runtime"
  "time"

  "github.com/moorara/observer"
  "go.opentelemetry.io/otel/api/correlation"
  "go.opentelemetry.io/otel/api/kv"
  "go.opentelemetry.io/otel/api/metric"
  "go.uber.org/zap"
)

type instruments struct {
  reqCounter   metric.Int64Counter
  reqDuration  metric.Float64ValueRecorder
  allocatedMem metric.Int64ValueObserver
}

func newInstruments(meter metric.Meter) *instruments {
  mm := metric.Must(meter)

  callback := func(ctx context.Context, result metric.Int64ObserverResult) {
    ms := new(runtime.MemStats)
    runtime.ReadMemStats(ms)
    result.Observe(int64(ms.Alloc),
      kv.String("function", "ReadMemStats"),
    )
  }

  return &instruments{
    reqCounter:   mm.NewInt64Counter("requests_total", metric.WithDescription("the total number of requests")),
    reqDuration:  mm.NewFloat64ValueRecorder("request_duration_seconds", metric.WithDescription("the duration of requests in seconds")),
    allocatedMem: mm.NewInt64ValueObserver("allocated_memory_bytes", callback, metric.WithDescription("number of bytes allocated and in use")),
  }
}

type server struct {
  observer    observer.Observer
  instruments *instruments
}

func (s *server) Handle(ctx context.Context) {
  // Tracing
  ctx, span := s.observer.Tracer().Start(ctx, "handle-request")
  defer span.End()

  start := time.Now()
  s.fetch(ctx)
  s.respond(ctx)
  duration := time.Now().Sub(start)

  labels := []kv.KeyValue{
    kv.String("method", "GET"),
    kv.String("endpoint", "/user"),
    kv.Uint("statusCode", 200),
  }

  // Metrics
  s.observer.Meter().RecordBatch(ctx, labels,
    s.instruments.reqCounter.Measurement(1),
    s.instruments.reqDuration.Measurement(duration.Seconds()),
  )

  // Logging
  s.observer.Logger().Info("request handled successfully.",
    zap.String("method", "GET"),
    zap.String("endpoint", "/user"),
    zap.Uint("statusCode", 200),
  )
}

func (s *server) fetch(ctx context.Context) {
  _, span := s.observer.Tracer().Start(ctx, "read-database")
  defer span.End()

  time.Sleep(50 * time.Millisecond)
}

func (s *server) respond(ctx context.Context) {
  _, span := s.observer.Tracer().Start(ctx, "send-response")
  defer span.End()

  time.Sleep(10 * time.Millisecond)
}

func main() {
  // Creating a new Observer and set it as the singleton
  obsv := observer.New(true, observer.Options{
    Name:        "my-service",
    Version:     "0.1.0",
    Environment: "production",
    Region:      "ca-central-1",
    Tags: map[string]string{
      "domain": "auth",
    },
    LogLevel:            "info",
    JaegerAgentEndpoint: "localhost:6831",
  })
  defer obsv.Close()

  srv := &server{
    observer:    obsv,
    instruments: newInstruments(obsv.Meter()),
  }

  // Creating a correlation context
  ctx := context.Background()
  ctx = correlation.NewContext(ctx,
    kv.String("tenant", "1234"),
  )

  srv.Handle(ctx)

  // Serving metrics endpoint
  http.Handle("/metrics", obsv)
  log.Fatal(http.ListenAndServe(":8080", nil))
}