Go SDK

The entro-go package provides a Go SDK for server-side analytics tracking with middleware support for popular web frameworks.

Installation

go get github.com/entro314labs/entro-go

Quick Start

Install Package

go get github.com/entro314labs/entro-go

Create a Client

package main

import (
    "log"
    entrolytics "github.com/entro314labs/entro-go"
)

func main() {
    client := entrolytics.NewClient("ent_xxx")
    
    // Track event
    err := client.Track(entrolytics.Event{
        WebsiteID: "your-website-id",
        Name:      "purchase",
        Data: map[string]interface{}{
            "revenue":  99.99,
            "currency": "USD",
        },
    })
    if err != nil {
        log.Fatal(err)
    }
}

Track Events

// Track page view
err := client.PageView(entrolytics.PageView{
    WebsiteID: "your-website-id",
    URL:       "/pricing",
    Referrer:  "https://google.com",
    Title:     "Pricing",
})

// Identify user
err := client.Identify(entrolytics.Identify{
    WebsiteID: "your-website-id",
    UserID:    "user_456",
    Traits: map[string]interface{}{
        "email": "user@example.com",
        "plan":  "pro",
    },
})

Configuration

client := entrolytics.NewClientWithOptions(entrolytics.ClientOptions{
    APIKey:    "ent_xxx",
    Host:      "https://analytics.yourcompany.com",
    Timeout:   15 * time.Second,
    UserAgent: "my-app/1.0",
})

Framework Integrations

Standard HTTP Middleware

package main

import (
    "log"
    "net/http"
    entrolytics "github.com/entro314labs/entro-go"
)

func trackMiddleware(next http.Handler, client *entrolytics.Client, websiteID string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Track page view
        go func() {
            err := client.PageView(entrolytics.PageView{
                WebsiteID: websiteID,
                URL:       r.URL.String(),
                Referrer:  r.Referer(),
                UserAgent: r.UserAgent(),
                IPAddress: getClientIP(r),
            })
            if err != nil {
                log.Printf("Failed to track: %v", err)
            }
        }()

        next.ServeHTTP(w, r)
    })
}

func getClientIP(r *http.Request) string {
    if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
        return strings.Split(xff, ",")[0]
    }
    return strings.Split(r.RemoteAddr, ":")[0]
}

Gin Middleware

package main

import (
    "github.com/gin-gonic/gin"
    entrolytics "github.com/entro314labs/entro-go"
)

func EntrolyticsMiddleware(client *entrolytics.Client, websiteID string) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()

        // Track after request completes
        go func() {
            client.PageView(entrolytics.PageView{
                WebsiteID: websiteID,
                URL:       c.Request.URL.String(),
                Referrer:  c.Request.Referer(),
                UserAgent: c.Request.UserAgent(),
                IPAddress: c.ClientIP(),
            })
        }()
    }
}

func main() {
    client := entrolytics.NewClient("ent_xxx")
    
    r := gin.Default()
    r.Use(EntrolyticsMiddleware(client, "your-website-id"))
    
    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "Hello"})
    })
    
    r.Run(":8080")
}

Echo Middleware

package main

import (
    "github.com/labstack/echo/v4"
    entrolytics "github.com/entro314labs/entro-go"
)

func EntrolyticsMiddleware(client *entrolytics.Client, websiteID string) echo.MiddlewareFunc {
    return func(next echo.HandlerFunc) echo.HandlerFunc {
        return func(c echo.Context) error {
            err := next(c)

            // Track after request
            go func() {
                client.PageView(entrolytics.PageView{
                    WebsiteID: websiteID,
                    URL:       c.Request().URL.String(),
                    Referrer:  c.Request().Referer(),
                    UserAgent: c.Request().UserAgent(),
                    IPAddress: c.RealIP(),
                })
            }()

            return err
        }
    }
}

func main() {
    client := entrolytics.New Client("ent_xxx")
    
    e := echo.New()
    e.Use(EntrolyticsMiddleware(client, "your-website-id"))
    
    e.GET("/", func(c echo.Context) error {
        return c.String(200, "Hello")
    })
    
    e.Start(":8080")
}

Chi Middleware

package main

import (
    "net/http"
    "github.com/go-chi/chi/v5"
    entrolytics "github.com/entro314labs/entro-go"
)

func EntrolyticsMiddleware(client *entrolytics.Client, websiteID string) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            next.ServeHTTP(w, r)

            // Track after request
            go func() {
                client.PageView(entrolytics.PageView{
                    WebsiteID: websiteID,
                    URL:       r.URL.String(),
                    Referrer:  r.Referer(),
                    UserAgent: r.UserAgent(),
                })
            }()
        })
    }
}

func main() {
    client := entrolytics.NewClient("ent_xxx")
    
    r := chi.NewRouter()
    r.Use(EntrolyticsMiddleware(client, "your-website-id"))
    
    r.Get("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello"))
    })
    
    http.ListenAndServe(":8080", r)
}

Context Support

All methods support context for cancellation and timeouts:

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

err := client.TrackWithContext(ctx, entrolytics.Event{
    WebsiteID: "your-website-id",
    Name:      "purchase",
    Data: map[string]interface{}{
        "revenue": 99.99,
    },
})

Advanced Usage

API Reference

Types

type Event struct {
    WebsiteID  string
    Name       string
    Data       map[string]interface{}
    URL        string
    Referrer   string
    UserID     string
    SessionID  string
    UserAgent  string
    IPAddress  string
    Timestamp  *time.Time
}

type PageView struct {
    WebsiteID  string
    URL        string
    Referrer   string
    Title      string
    UserID     string
    SessionID  string
    UserAgent  string
    IPAddress  string
    Timestamp  *time.Time
}

type Identify struct {
    WebsiteID string
    UserID    string
    Traits    map[string]interface{}
    Timestamp *time.Time
}

Requirements

Go >= 1.21

Features

✅ Context support for timeouts/cancellation
✅ Middleware for popular frameworks
✅ Comprehensive error types
✅ Custom HTTP client support
✅ Concurrent-safe
✅ Zero dependencies

Support

GitHub Issues
Email: hey@entrolytics.click

Go SDK

Error Handling

Custom HTTP Client

Batch Tracking

Table of Contents