metis

README

Metis GO Interceptor

Documentation

Supported GO packages

• http:
  1. net/http
  2. gorilla/mux
• postgres:
  1. lib/pq
  2. gorm
  3. ido50/sqlz

Usage

• Run

go get github.com/metis-data/go-interceptor \
  go.opentelemetry.io/otel \
  go.opentelemetry.io/otel/sdk/trace

• Set the api key environment variable: METIS_API_KEY

  Metis Api Key can be generated at Metis

• Enable Otel instrumentation:

  1. Set up Tracer:

  import (
    metis "github.com/metis-data/go-interceptor"
    _ "github.com/lib/pq"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/sdk/trace"
  )
  
  var tp *trace.TracerProvider
  var err error
  tp, err = metis.NewTracerProvider()
  if err != nil {
    log.Fatal(err)
  }
  defer func() {
    if err := tp.Shutdown(context.Background()); err != nil {
      log.Fatal(err)
    }
  }()
  otel.SetTracerProvider(tp)
  

  1. Wrap your http server with metis:

  // net/http
  
  import (
    "fmt"
    "net/http"
  
    metis "github.com/metis-data/go-interceptor"
    _ "github.com/lib/pq"
  )
  
  // use metis.NewServeMux() instead of http.NewServeMux()
  mux := metis.NewServeMux() 
  mux.HandleFunc("/api/endpoint", someHandler)
  ...
  
  // Wrap the router with the metis handler
  handler := metis.NewHandler(mux, "my-web-service")
  err = http.ListenAndServe(fmt.Sprintf(":%s", port), handler)
  

  // gorilla/mux
  
  import (
    "fmt"
    "net/http"
  
    "github.com/gorilla/mux"
    metis "github.com/metis-data/go-interceptor"
    _ "github.com/lib/pq"
  )
  
  // Create a new gorilla/mux router
  router := mux.NewRouter()
  
  router.HandleFunc("/api/endpoint", someHandler)
  ...
  
  // Wrap the router with the metis handler
  metisRouter, err := metis.WrapGorillaMuxRouter(router)
  if err != nil {
      log.Fatal(err)
  }
  handler := metis.NewHandler(metisRouter, "web-go-gorm")
  err = http.ListenAndServe(fmt.Sprintf(":%s", port), handler)
  

  1. Wrap your database connection with metis:

  
  import (
    "database/sql"
    "fmt"
    "log"
  
    metis "github.com/metis-data/go-interceptor"
    _ "github.com/lib/pq"
  )
  
  dbHost := "postgres"
  dbPort := 5432
  dbUser := "postgres"
  dbPassword := "postgres"
  dbName := "my_database"
  dbSchema := "my_schema"
  
  dataSourceName := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
      dbHost, dbPort, dbUser, dbPassword, dbName)
  
  var db *sql.DB
  var err error
  
  // Open a connection to the database via metis API
  db, err = metis.OpenDB(dataSourceName)
  if err != nil {
      log.Fatal(err)
  }
  defer db.Close()
  

  1. Pass context in queries:

  // lib/pq
  
  import (
    "database/sql"
    "fmt"
    "log"
    "net/http"
  )
  
  query := fmt.Sprintf("SELECT id, name FROM %s.my_table", dbSchema)
  
  var rows *sql.Rows
  var err error
  
  // make sure to pass the context here
  // r *http.Request
  rows, err = db.QueryContext(r.Context(), query)
  if err != nil {
      log.Fatal(err)
  }
  defer rows.Close()
  

  // gorm
  
  import (
    "database/sql"
    "fmt"
    "log"
    "net/http"
  
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
  )
  
  query := fmt.Sprintf("SELECT id, name FROM %s.my_table", dbSchema)
  
  var gormDB *gorm.DB
  var err error
  
  gormDB, err = gorm.Open(postgres.New(postgres.Config{
      Conn: db,
  }), &gorm.Config{})
  if err != nil {
      log.Fatal(err)
  }
  
  // make sure to pass the context here
  // r *http.Request
  gormDB = gormDB.WithContext(r.Context())
  var users []User
  gormDB.Raw(query).Find(&users)
  

  // ido50/sqlz
  
  import (
    "database/sql"
    "fmt"
    "log"
    "net/http"
  
    "github.com/ido50/sqlz"
  )
  
  var sqlzDB *sqlz.DB
  var user User
  var err error
  
  sqlzDB = sqlz.New(db, "postgres")
  
  // make sure to pass the request context here
  // r *http.Request
  err = sqlzDB.
  Select("id", "name").
  From("my_schema.my_table").
  GetRowContext(r.Context(), &user)
  if err != nil {
    panic(err)
  }
  

Examples

• net/http + lib/pq
• gorilla/mux + gorm
• gorilla/mux + ido50/sqlz

Issues

If you would like to report a potential issue please use Issues

License Summary

This code is made available under the MIT license.

Documentation

Index

• func NewHandler(handler http.Handler, operation string, opts ...otelhttp.Option) http.Handler
• func NewTracerProvider() (*trace.TracerProvider, error)
• func NewTracerProviderWithLogin(url, apiKey string) (*trace.TracerProvider, error)
• func OpenDB(dataSourceName string) (*sql.DB, error)
• func WrapGorillaMuxRouter(router *mux.Router) (*mux.Router, error)
• func WrapHandler(handler http.Handler, pattern string) http.Handler
• func WrapHandlerFunc(handlerFunc http.HandlerFunc, pattern string) http.HandlerFunc
• type ServeMux
  • func NewServeMux() *ServeMux
  • func (sm *ServeMux) Handle(pattern string, handler http.Handler)
  • func (sm *ServeMux) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
  • func (sm *ServeMux) Handler(r *http.Request) (h http.Handler, pattern string)
  • func (sm *ServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request)

Functions

func NewHandler

func NewHandler(handler http.Handler, operation string, opts ...otelhttp.Option) http.Handler

NewHandler returns a new http.Handler that instruments requests with OpenTelemetry.

func NewTracerProvider

func NewTracerProvider() (*trace.TracerProvider, error)

NewTracerProvider returns a new tracer provider with the metis exporter. The url and apiKey can be set with the environment variables METIS_EXPORTER_URL and METIS_API_KEY.

func NewTracerProviderWithLogin

func NewTracerProviderWithLogin(url, apiKey string) (*trace.TracerProvider, error)

NewTracerProviderWithLogin returns a new tracer provider with the metis exporter.

func OpenDB

func OpenDB(dataSourceName string) (*sql.DB, error)

OpenDB returns a new wrapped sql.DB connection.

func WrapGorillaMuxRouter

func WrapGorillaMuxRouter(router *mux.Router) (*mux.Router, error)

func WrapHandler

func WrapHandler(handler http.Handler, pattern string) http.Handler

WrapHandler wraps an http.Handler with OpenTelemetry instrumentation.

func WrapHandlerFunc

func WrapHandlerFunc(handlerFunc http.HandlerFunc, pattern string) http.HandlerFunc

WrapHandlerFunc wraps an http.HandlerFunc with OpenTelemetry instrumentation.

Types

type ServeMux

type ServeMux struct {
	*http.ServeMux
}

func NewServeMux

func NewServeMux() *ServeMux

func (*ServeMux) Handle

func (sm *ServeMux) Handle(pattern string, handler http.Handler)

func (*ServeMux) HandleFunc

func (sm *ServeMux) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))

func (*ServeMux) Handler

func (sm *ServeMux) Handler(r *http.Request) (h http.Handler, pattern string)

func (*ServeMux) ServeHTTP

func (sm *ServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request)