Vinícius Boscardin

Posted on Jul 13, 2022 • Edited on Jul 17, 2022

Golang, observabilidade e métricas com SigNoz e OpenTelemetry

#go #metrics #api #signoz

Quem nunca passou por um aperto com uma api, endpoit, serviço ou qualquer coisa em produção e simplesmente não achou o problema ou demorou muito tempo para metrificar e descobrir o gargalo que fazia o sistema cair? É, aquela hora do dia que o sistema simplesmente ficava inutilizável e ninguém sabia explicar o motivo? Se você não passou por isso sempre vai ter a primeira vez... Brincadeiras a parte, hoje veremos como integrar um serviço criado com golang com o SigNoz usando OpenTelemetry

Bora lá! Primeiro passo é ter um serviço para metrificar! rsrs... Vamos criar algo muito simples para não perdermos tempo. O foco aqui é a integração com o SigNoz e não uma API completa com Golang.

Aplicação

Iniciaremos com:

mkdir go-signoz-otl
cd go-signoz-otl
go mod init github.com/booscaaa/go-signoz-otl

Vamos configurar nossa migration de produtos para o exemplo.

migrate create -ext sql -dir database/migrations -seq create_product_table

No nosso arquivo database/migrations/000001_create_product_table.up.sql

CREATE TABLE product(
    id serial primary key not null,
    name varchar(100) not null
);

INSERT INTO product (name) VALUES 
    ('Cadeira'),
    ('Mesa'),
    ('Toalha'),
    ('Fogão'),
    ('Batedeira'),
    ('Pia'),
    ('Torneira'),
    ('Forno'),
    ('Gaveta'),
    ('Copo');

Com a migration em mãos, bora criar já de início nosso conector com o postgres usando a lib sqlx.
adapter/postgres/connector.go

package postgres

import (
    "context"
    "log"

    "github.com/golang-migrate/migrate/v4"
    "github.com/jmoiron/sqlx"
    "github.com/spf13/viper"

    _ "github.com/golang-migrate/migrate/v4/database/postgres"
    _ "github.com/golang-migrate/migrate/v4/source/file"
    _ "github.com/lib/pq"
)

// GetConnection return connection pool from postgres drive SQLX
func GetConnection(context context.Context) *sqlx.DB {
    databaseURL := viper.GetString("database.url")

    db, err := sqlx.ConnectContext(
        context,
        "postgres",
        databaseURL,
    )
    if err != nil {
        log.Fatal(err)
    }

    return db
}

// RunMigrations run scripts on path database/migrations
func RunMigrations() {
    databaseURL := viper.GetString("database.url")
    m, err := migrate.New("file://database/migrations", databaseURL)
    if err != nil {
        log.Println(err)
    }

    if err := m.Up(); err != nil {
        log.Println(err)
    }
}

Vamos criar as abstrações e implementações no nosso dominio/adapters da aplicação.

core/domain/product.go

package domain

import (
    "context"

    "github.com/gin-gonic/gin"
)

// Product is entity of table product database column
type Product struct {
    ID   int32  `json:"id" db:"id"`
    Name string `json:"name" db:"name"`
}

// ProductService is a contract of http adapter layer
type ProductService interface {
    Fetch(*gin.Context)
}

// ProductUseCase is a contract of business rule layer
type ProductUseCase interface {
    Fetch(context.Context) (*[]Product, error)
}

// ProductRepository is a contract of database connection adapter layer
type ProductRepository interface {
    Fetch(context.Context) (*Product, error)
}

core/usecase/productusecase/new.go

package productusecase

import "github.com/booscaaa/go-signoz-otl/core/domain"

type usecase struct {
    repository domain.ProductRepository
}

// New returns contract implementation of ProductUseCase
func New(repository domain.ProductRepository) domain.ProductUseCase {
    return &usecase{
        repository: repository,
    }
}

core/usecase/productusecase/fetch.go

package productusecase

import (
    "context"

    "github.com/booscaaa/go-signoz-otl/core/domain"
)

func (usecase usecase) Fetch(ctx context.Context) (*[]domain.Product, error) {
    products, err := usecase.repository.Fetch(ctx)

    if err != nil {
        return nil, err
    }

    return products, err
}

adapter/postgres/productrepository/new.go

package productrepository

import (
    "github.com/booscaaa/go-signoz-otl/core/domain"
    "github.com/jmoiron/sqlx"
)

type repository struct {
    db *sqlx.DB
}

// New returns contract implementation of ProductRepository
func New(db *sqlx.DB) domain.ProductRepository {
    return &repository{
        db: db,
    }
}

adapter/postgres/productrepository/fetch.go

package productrepository

import (
    "context"

    "github.com/booscaaa/go-signoz-otl/core/domain"
)

func (repository repository) Fetch(ctx context.Context) (*[]domain.Product, error) {
    products := []domain.Product{}

    err := repository.db.SelectContext(ctx, &products, "SELECT * FROM product;")

    if err != nil {
        return nil, err
    }

    return &products, nil
}

adapter/http/productservice/new.go

package productservice

import "github.com/booscaaa/go-signoz-otl/core/domain"

type service struct {
    usecase domain.ProductUseCase
}

// New returns contract implementation of ProductService
func New(usecase domain.ProductUseCase) domain.ProductService {
    return &service{
        usecase: usecase,
    }
}

adapter/http/productservice/fetch.go

package productservice

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func (service service) Fetch(c *gin.Context) {
    products, err := service.usecase.Fetch(c.Request.Context())

    if err != nil {
        c.JSON(http.StatusInternalServerError, err)
        return
    }

    c.JSON(http.StatusOK, products)
}

di/product.go

package di

import (
    "github.com/booscaaa/go-signoz-otl/adapter/http/productservice"
    "github.com/booscaaa/go-signoz-otl/adapter/postgres/productrepository"
    "github.com/booscaaa/go-signoz-otl/core/domain"
    "github.com/booscaaa/go-signoz-otl/core/usecase/productusecase"
    "github.com/jmoiron/sqlx"
)

func ConfigProductDI(conn *sqlx.DB) domain.ProductService {
    productRepository := productrepository.New(conn)
    productUsecase := productusecase.New(productRepository)
    productService := productservice.New(productUsecase)

    return productService
}

adapter/http/main.go

package main

import (
    "context"

    "github.com/booscaaa/go-signoz-otl/adapter/postgres"
    "github.com/booscaaa/go-signoz-otl/di"
    "github.com/gin-gonic/gin"
    "github.com/spf13/viper"
)

func init() {
    viper.SetConfigFile(`config.json`)
    err := viper.ReadInConfig()
    if err != nil {
        panic(err)
    }
}

func main() {
    ctx := context.Background()
    conn := postgres.GetConnection(ctx)
    defer conn.Close()

    postgres.RunMigrations()

    productService := di.ConfigProductDI(conn)

    router := gin.Default()
    router.GET("/product", productService.Fetch)
    router.Run(":3000")
}

config.json

{
    "database": {
        "url": "postgres://postgres:postgres@localhost:5432/devtodb"
    },
    "server": {
        "port": "3000"
    },
    "otl": {
        "service_name": "devto_goapp",
        "otel_exporter_otlp_endpoint": "localhost:4317",
        "insecure_mode": true
    }
}

Por fim basta rodar a aplicação e ver se tudo ficou funcionando certinho!
No primeiro terminal:

go run adapter/http/main.go

No segundo terminal:

curl --location --request GET 'localhost:3000/product'

SigNoz

Com a aplicação pronta, vamos iniciar as devidas implementações para integrar as métricas com o SigNoz e ver a magia acontecer!
Primeiro passo então é instalarmos o SigNoz na nossa máquina, para isso usaremos o docker-compose.

git clone -b main https://github.com/SigNoz/signoz.git && cd signoz/deploy/

docker-compose -f docker/clickhouse-setup/docker-compose.yaml up -d

Feito isso basta acessar o endereço localhost:3301 no seu navegador.

Crie uma conta e acesse o painel do SigNoz.

No Dashboard inicial ainda não temos nada que nos interesse, mas fique a vontade para explorar os dados ja existentes da aplicação.

Por fim vamos realizar a integração e analisar os dados que serão mostrados no SigNoz.

Vamos começar alterando o conector com o banco de dados, criando um wrapper do sqlx com a lib otelsqlx, com isso vamos conseguir captar informações de queries que serão executadas no banco.

core/postgres/connector.go

package postgres

import (
    "context"
    "log"

    "github.com/golang-migrate/migrate/v4"
    "github.com/jmoiron/sqlx"
    "github.com/spf13/viper"
    "github.com/uptrace/opentelemetry-go-extra/otelsql"
    "github.com/uptrace/opentelemetry-go-extra/otelsqlx"
    semconv "go.opentelemetry.io/otel/semconv/v1.4.0"

    _ "github.com/golang-migrate/migrate/v4/database/postgres"
    _ "github.com/golang-migrate/migrate/v4/source/file"
    _ "github.com/lib/pq"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

// GetConnection return connection pool from postgres drive SQLX
func GetConnection(context context.Context, provider *sdktrace.TracerProvider) *sqlx.DB {
    databaseURL := viper.GetString("database.url")

    db, err := otelsqlx.ConnectContext(
        context,
        "postgres",
        databaseURL,
        otelsql.WithAttributes(semconv.DBSystemPostgreSQL),
        otelsql.WithTracerProvider(provider),
    )
    if err != nil {
        log.Fatal(err)
    }

    return db
}

// RunMigrations run scripts on path database/migrations
func RunMigrations() {
    databaseURL := viper.GetString("database.url")
    m, err := migrate.New("file://database/migrations", databaseURL)
    if err != nil {
        log.Println(err)
    }

    if err := m.Up(); err != nil {
        log.Println(err)
    }
}

Feito isso criaremos o arquivo util/tracer.go para inicializar a captura das informações.

package util

import (
    "context"
    "log"

    "github.com/spf13/viper"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/sdk/resource"
    "google.golang.org/grpc/credentials"

    sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

var (
    ServiceName  = ""
    CollectorURL = ""
    Insecure     = false
)

func InitTracer() *sdktrace.TracerProvider {
    ServiceName = viper.GetString("otl.service_name")
    CollectorURL = viper.GetString("otl.otel_exporter_otlp_endpoint")
    Insecure = viper.GetBool("otl.insecure_mode")

    secureOption := otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
    if Insecure {
        secureOption = otlptracegrpc.WithInsecure()
    }

    ctx := context.Background()

    exporter, err := otlptrace.New(
        ctx,
        otlptracegrpc.NewClient(
            secureOption,
            otlptracegrpc.WithEndpoint(CollectorURL),
        ),
    )

    if err != nil {
        log.Fatal(err)
    }

    resources, err := resource.New(
        ctx,
        resource.WithAttributes(
            attribute.String("service.name", ServiceName),
            attribute.String("library.language", "go"),
        ),
    )

    if err != nil {
        log.Printf("Could not set resources: %v", err)
    }

    provider := sdktrace.NewTracerProvider(
        sdktrace.WithSampler(sdktrace.AlwaysSample()),
        sdktrace.WithBatcher(exporter),
        sdktrace.WithResource(resources),
    )

    otel.SetTracerProvider(
        provider,
    )
    return provider
}

E por último, mas não menos importante, vamos configurar o middleware para o gin no arquivo adapter/http/main.go

package main

import (
    "context"

    "github.com/booscaaa/go-signoz-otl/adapter/postgres"
    "github.com/booscaaa/go-signoz-otl/di"
    "github.com/booscaaa/go-signoz-otl/util"
    "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"

    "github.com/gin-gonic/gin"
    "github.com/spf13/viper"
)

func init() {
    viper.SetConfigFile(`config.json`)
    err := viper.ReadInConfig()
    if err != nil {
        panic(err)
    }
}

func main() {
    tracerProvider := util.InitTracer()
    ctx := context.Background()
    conn := postgres.GetConnection(ctx, tracerProvider)
    defer conn.Close()

    postgres.RunMigrations()

    productService := di.ConfigProductDI(conn)

    router := gin.Default()
    router.Use(otelgin.Middleware(util.ServiceName))
    router.GET("/product", productService.Fetch)
    router.Run(":3000")
}

Vamos rodar novamente a aplicação e criar um script para realizar diversas chamadas na api.
No primeiro terminal:

go run adapter/http/main.go

No segundo terminal:

while :
do
    curl --location --request GET 'localhost:3000/product'
done

Voltando para o painel do SigNoz basta esperar a aplicação aparecer no dashboard.

Clicando no app que acabou de aparecer já conseguimos analisar dados muito importantes como:

Media de tempo de cada request.
Quantidade de requests por segundo.
Qual o endpoint mais acessado da aplicação.
Porcentagem de erros que ocorreram.

E ao clicar em uma request que por ventura demorou muito para retornar ou deu erro, chegaremos a uma nova tela onde é possivel analisar o tempo interno de cada camada, além de ver exatamente a query que pode estar causando problemas na aplicação.