Ir herramientas de medición de software

En este artículo, me gustaría compartir una forma de perfilar y rastrear programas en Go. Le mostraré cómo hacer esto mientras mantengo el código flexible y limpio.

TL; DR

El registro, la recopilación de métricas y todo lo que no esté conectado con la funcionalidad principal de cualquier código no debe estar dentro de este código. En su lugar, debe identificar los puntos de rastreo que el usuario puede usar para medir el código.

En otras palabras, el registro y la recopilación de métricas son subconjuntos de la traza .

El código de seguimiento de plantilla se puede generar usando gtrace .

Problema

Supongamos que tenemos un paquete liby alguna estructura lib.Client. Antes de ejecutar cualquier solicitud, lib.Clientverifica la conexión:

package lib

type Client struct {
    conn net.Conn
}

func (c *Client) Request(ctx context.Context) error {
    if err := c.ping(ctx); err != nil {
        return err
    }
    // Some logic here.
}

func (c *Client) ping(ctx context.Context) error {
    return doPing(ctx, c.conn)
}

¿Qué sucede si queremos grabar en el registro justo antes y justo después de enviar el mensaje de ping? La primera opción es incrustar el registrador (o su interfaz) en Client:

package lib

type Client struct {
    Logger Logger

    conn net.Conn
}

func (c *Client) ping(ctx context.Context) (err error) {
    c.Logger.Info("ping started")
    err = doPing(ctx, c.conn)
    c.Logger.Info("ping done (err is %v)", err)
    return
}

Si queremos recopilar alguna métrica, podemos hacer lo mismo:

package lib

type Client struct {
    Logger  Logger
    Metrics Registry

    conn net.Conn
}

func (c *Client) ping(ctx context.Context) (err error) {
    start := time.Now()
    c.Logger.Info("ping started")

    err = doPing(ctx, c.conn)

    c.Logger.Info("ping done (err is %v)", err)
    metric := c.Metrics.Get("ping_latency")
    metric.Send(time.Since(start))

    return err
}

, – . Client, , ó , ( doPing()).

( Client) .

, , , ? , , ?

, Client.

, , - . , (SRP).

, Client ? , , ? , Go, , .

, :

,
.

, ( ), ( ).

, , .

, , httptrace Go.

, : OnPingStart() OnPingDone(), OnPing(), callback. OnPing() ping-, callback – . (, doPing()).

Client :

package lib

type Client struct {
    OnPing func() func(error)
    conn net.Conn
}

func (c *Client) ping(ctx context.Context) (err error) {
    done := c.OnPing()
    err = doPing(ctx, c.conn)
    done(err)
    return
}

, OnPing nil. :

func (c *Client) ping(ctx context.Context) (err error) {
    var done func(error)
    if fn := c.OnPing; fn != nil {
        done = fn()
    }
    err = doPing(ctx, c.conn)
    if done != nil {
        done(err)
    }
    return
}

SRP , .

, .

?
httptrace ClientTrace.compose(), n . n ( ).

( reflect). OnPing Client ClientTrace:

package lib

type Client struct {
    Trace ClientTrace
    conn net.Conn
}

type ClientTrace struct {
    OnPing func() func(error)
}

:

func (a ClientTrace) Compose(b ClientTrace) (c ClientTrace) {
    switch {
    case a.OnPing == nil:
        c.OnPing = b.OnPing
    case b.OnPing == nil:
        c.OnPing = a.OnPing
    default:
        c.OnPing = func() func(error) {
            doneA := a.OnPing()
            doneB := b.OnPing() 
            switch {
            case doneA == nil:
                return doneB
            case doneB == nil:
                return doneA
            default:
                return func(err error) {
                    doneA(err)
                    doneB(err)
                }
            }
        }
    }
    return c
}

, ? , .

:

package main

import (
    "log"

    "some/path/to/lib"
)

func main() {
    var trace lib.ClientTrace

    // Logging hooks.
    trace = trace.Compose(lib.ClientTrace{
        OnPing: func() func(error) {
            log.Println("ping start")
            return func(err error) {
                log.Println("ping done", err)
            }
        },
    })

    // Some metrics hooks.
    trace = trace.Compose(lib.ClientTrace{
        OnPing: func() func(error) {
            start := time.Now()
            return func(err error) {
                metric := stats.Get("ping_latency")
                metric.Send(time.Since(start))
            }
        },
    })

    c := lib.Client{
        Trace: trace,
    }
}

. ClientTrace context.Context, Client.Request():

package lib

type clientTraceContextKey struct{}

func ClientTrace(ctx context.Context) ClientTrace {
    t, _ := ctx.Value(clientTraceContextKey{})
    return t
}

func WithClientTrace(ctx context.Context, t ClientTrace) context.Context {
    prev := ContextClientTrace(ctx)
    return context.WithValue(ctx,
        clientTraceContextKey{},
        prev.Compose(t),
    )
}

. , !

?

, Vim ( - ), .

, , nil , reflection.

github.com/gobwas/gtrace

gtrace . , //gtrace:gen. - nil, .

.

:

package lib

//go:generate gtrace

//gtrace:gen
//gtrace:set context
type ClientTrace struct {
    OnPing func() func(error)
}

type Client struct {
    Trace ClientTrace
    conn net.Conn
}

func (c *Client) ping(ctx context.Context) (err error) {
    done := c.Trace.onPing(ctx)
    err = doPing(ctx, c.conn)
    done(err)
    return
}

go generate ClientTrace.

! gtrace , .

!

References

• github.com/gobwas/gtrace
• Minimalistic C libraries by Chris
  Wellons. -
  .
• : Instrumentation in Go.