Configuration du traçage natif pour les fonctions d' AWS Lambda s basées sur l' Go

Pour ajouter le instalambda module à votre projet Lambda sur Go, exécutez la commande suivante depuis le dossier contenant le go.mod fichier :

go get github.com/instana/go-sensor/instrumentation/instalambda

Cette commande ajoute le module d'instrumentation à la liste des dépendances de votre projet ainsi qu'au tracer principal Go.

L'extrait de code suivant présente une fonction « AWS Lambda » typique écrite en langage « Go » :

package main

import (
    "github.com/aws/aws-lambda-go/lambda"
)

func main() {
    lambda.Start(Handle)
}

func Handle() (string, error) {
    // handler code
}

Une fonction de gestion peut prendre et renvoyer jusqu'à deux arguments, à condition que, si elle en prend deux, le premier argument soit de type context.Context.

Pour instrumenter une fonction de gestionnaire, procédez comme suit:

1. Créez un gestionnaire instrumenté à partir de la fonction de gestionnaire d'origine à l'aide de instalambda.NewHandler() .
2. Transmettez le gestionnaire instrumenté à lambda.StartHandler(). Le fragment suivant illustre les modifications de code:

package main

import (
    "github.com/aws/aws-lambda-go/lambda"

    // Import the in-process sensor and instrumentation packages
    instana "github.com/instana/go-sensor"
    "github.com/instana/go-sensor/instrumentation/instalambda"
)

func main() {
    // Initialize the instana.Sensor instance
    sensor := instana.NewSensor("my-lambda-handler")

    // Create an instrumented handler from your handler function
    h := instalambda.NewHandler(Handle, sensor)

    // Pass the handler to the lambda.StartHandler() invoke loop
    lambda.StartHandler(h)
}

func Handle() (string, error) {
    // handler code
}

L'extrait de code suivant présente un gestionnaire typique de l' AWS Lambda, implémenté comme suit lambda.Handler:

package main

import (
    "github.com/aws/aws-lambda-go/lambda"
)

func main() {
    h := &Handler{
        // handler configuration
    }

    lambda.StartHandler(h, sensor)
}

type Handler struct {
    // ...
}

func (h *Handler) Invoke(ctx context.Context, payload []byte) ([]byte, error) {
    // handler code
}

Pour implémenter un tel gestionnaire, encapsulez-le dans instalambda.WrapHandler() et transmettez-le à labmda.StartHandler():

package main

import (
    "github.com/aws/aws-lambda-go/lambda"

    // Import the in-process sensor and instrumentation packages
    instana "github.com/instana/go-sensor"
    "github.com/instana/go-sensor/instrumentation/instalambda"
)

func main() {
    // Initialize the instana.Sensor instance
    sensor := instana.NewSensor("my-lambda-handler")

    h := &Handler{
        // handler configuration
    }

    // Wrap and pass the handler to the lambda.StartHandler() invoke loop
    lambda.StartHandler(instalambda.WrapHandler(h, sensor))
}

type Handler struct {
    // ...
}

func (h *Handler) Invoke(ctx context.Context, payload []byte) ([]byte, error) {
    // handler code
}

Pour activer la propagation du contexte de trace, vous avez besoin d'une instrumentation minimale qui implique d'apporter quelques modifications à votre fonction main() sans mettre à jour votre code de gestionnaire. Toutefois, vous pouvez ajouter context.Context à la liste des arguments de votre fonction de gestionnaire. Lorsque vous ajoutez context.Context en tant qu'argument, instalambda injecte les étendues de l'événement déclencheur Lambda dans le contexte. Vous pouvez extraire ces étendues avec instana.SpanFromContext() et les utiliser en tant que parent pour tracer les appels internes et externes effectués dans le gestionnaire:

func MyHandler(ctx context.Context) error {
    // Pass the handler context to a subcall to trace its execution
    subCall(ctx)

    // ...

    // Propagate the trace context within an HTTP request to another service monitored with Instana
    // using an instrumented http.Client
    req, err := http.NewRequest("GET", url, nil)
    client := &http.Client{
        Transport: instana.RoundTripper(sensor, nil),
    }

    client.Do(req.WithContext(ctx))

    // ...
}

func subCall(ctx context.Context) {
    if parent, ok := instana.SpanFromContext(ctx); ok {
        // start a new span, using the Lambda entry span as a parent
        sp = parent.Tracer().StartSpan(/* ... */)
        defer sp.Finish()
    }

    // ...
}