This page guides you through the steps of configuring your Chi application to work with Apitally. If you don’t have an account yet, now would be a good time to sign up.

Once you’re done with this guide, you will be able to:

  • Analyze traffic to your application
  • Keep track of errors, response times and payload sizes
  • Understand how individual API consumers use your application
  • Log and inspect each API request and response
  • Monitor your application’s uptime and receive alerts when it’s down
  • Set up custom alert rules and get notified when they’re triggered

​
Create app

To get started, create a new app in the Apitally dashboard and select as your framework.

Here you can also configure the environments (e.g. prod and dev) for your app, or simply accept the defaults.

Take a note of the client ID displayed after submitting. You will need it in the next step.

​
Add middleware

Add the Apitally SDK to the dependencies in your Chi project.

go get github.com/apitally/apitally-go/chi

Add the Apitally middleware to your Chi application and provide the ClientId for your app. You’ll find the ClientId on the Setup instructions page for your app in the Apitally dashboard, which is displayed immediately after creating the app.

package main

import (
    apitally "github.com/apitally/apitally-go/chi"
    "github.com/go-chi/chi/v5"
)

func main() {
    r := chi.NewRouter()

    config := &apitally.Config{
        ClientId: "your-client-id",
        Env:      "dev", // or "prod" etc.
    }
    r.Use(apitally.Middleware(r, config))

    // ... rest of your code ...
}

Add the Apitally middleware before any other middleware to ensure it wraps the entire stack.

Deploy your application with these changes, or restart if you're testing locally.

At this point the basic setup for your application is complete and you will start seeing data in the Apitally dashboard. However, you won't be able to analyze API consumers yet.

​
Identify consumers

In order to analyze API traffic by consumers in Apitally, your application must identify which consumers requests are coming from.

How you identify API consumers depends on your application and use case. If your application uses authentication, it would make sense to use the authenticated identity (e.g. username) as the consumer identifier.

To associate requests with consumers, use the SetConsumerIdentifier or SetConsumer function, for example in a middleware.

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Your authentication logic here
        // ...

        if user.IsAuthenticated() {
            // Use the authenticated identity as consumer identifier
            apitally.SetConsumerIdentifier(r, user.Identifier)
        }
        next.ServeHTTP(w, r)
    })
}

The consumer identifier should be a string (max. 128 characters long) that uniquely identifies the consumer of the API, e.g. customer-123. Once the first request is received from a consumer, it will show up in the Apitally dashboard.

Now the Consumers page in the Apitally dashboard shows you information about all consumers that have made requests to your application. You can also filter insights on other the dashboards by consumer and better understand how each of them use your application.

​
Capture validation errors

If you’re using the go-playground/validator/v10 package to validate incoming data, you can use the CaptureValidationError function to record validation errors. This gives you visibility into the validation errors returned by your API endpoints.

package main

import (
    "encoding/json"
    "net/http"

    apitally "github.com/apitally/apitally-go/chi"
    "github.com/go-chi/chi/v5"
    "github.com/go-playground/validator/v10"
)

type HelloRequest struct {
    Name string `json:"name" validate:"required"`
}

func main() {
    r := chi.NewRouter()
    validate := validator.New()

    // ...

    r.Post("/hello", func(w http.ResponseWriter, r *http.Request) {
        var req HelloRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        if err := validate.Struct(req); err != nil {
            apitally.CaptureValidationError(r, err)
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        json.NewEncoder(w).Encode(map[string]string{"message": "Hello, " + req.Name + "!"})
    })

    // ...
}

​
Configure request logging

Logging of individual requests and responses is disabled by default to protect potentially sensitive data. You can enable it by providing a RequestLoggingConfig object, which allows you to configure in detail what parts of the request and response should be logged. There are also options for masking sensitive information and excluding certain requests from logging.

package main

import (
    apitally "github.com/apitally/apitally-go/chi"
    "github.com/go-chi/chi/v5"
)

func main() {
    r := chi.NewRouter()

    config := &apitally.Config{
        ClientId: "your-client-id",
        Env:      "dev", // or "prod" etc.
        RequestLoggingConfig: &apitally.RequestLoggingConfig{
            Enabled:            true,
            LogQueryParams:     true,
            LogRequestHeaders:  true,
            LogRequestBody:     true,
            LogResponseHeaders: true,
            LogResponseBody:    true,
            LogPanic:           true,
        },
    }
    r.Use(apitally.Middleware(r, config))

    // ... rest of your code ...
}