feat: add User-Agent header with SDK version (#181)

* feat: add User-Agent header with SDK version

Implements #175

- Add getUserAgent() function that uses runtime/debug.ReadBuildInfo() to detect SDK version
- User-Agent format: flagsmith-go-sdk/<version> or flagsmith-go-sdk/unknown in development
- Added comprehensive unit and integration tests
- Exported getUserAgent() via export_test.go for testing purposes

* don't generate eval context

* fix version when used as dep

* fixup

* fixup; test

Author: gagantrivedi

.github/workflows/go.yml

@@ -30,9 +30,6 @@ jobs:
       with:
         submodules: recursive
 
-    - name: Build evaluation context struct
-      run: make generate-evaluation-context
-
     - name: Get dependencies
       run: |
         go get -v -t -d ./...

client.go

@@ -97,6 +97,7 @@ func NewClient(apiKey string, options ...Option) *Client {
 
 	c.client.SetHeaders(map[string]string{
 		"Accept":             "application/json",
+		"User-Agent":         getUserAgent(),
 		EnvironmentKeyHeader: c.apiKey,
 	})
 

client_test.go

@@ -107,6 +107,38 @@ func TestClientErrorsIfLocalEvaluationModeAndOfflineHandlerAreBothSet(t *testing
 		flagsmith.WithLocalEvaluation(context.Background()))
 }
 
+func TestUserAgentHeaderIsSent(t *testing.T) {
+	// Given
+	userAgentReceived := ""
+	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
+		userAgentReceived = req.Header.Get("User-Agent")
+		rw.Header().Set("Content-Type", "application/json")
+		rw.WriteHeader(http.StatusOK)
+		_, err := io.WriteString(rw, fixtures.EnvironmentJson)
+		if err != nil {
+			panic(err)
+		}
+	}))
+	defer server.Close()
+
+	// When
+	client := flagsmith.NewClient(fixtures.EnvironmentAPIKey,
+		flagsmith.WithBaseURL(server.URL+"/api/v1/"))
+	_, _ = client.GetEnvironmentFlags(context.Background())
+
+	// Then
+	// Get the expected User-Agent value from the SDK's getUserAgent() function
+	expectedUserAgent := flagsmith.GetUserAgentForTest()
+
+	assert.NotEmpty(t, userAgentReceived, "User-Agent header should be sent")
+	assert.Equal(t, expectedUserAgent, userAgentReceived,
+		"User-Agent header should match the value returned by getUserAgent()")
+
+	// Verify basic format requirements
+	assert.True(t, strings.HasPrefix(userAgentReceived, "flagsmith-go-sdk/"),
+		"User-Agent should start with 'flagsmith-go-sdk/', got: %s", userAgentReceived)
+}
+
 func TestClientUpdatesEnvironmentOnStartForLocalEvaluation(t *testing.T) {
 	// Given
 	ctx := context.Background()

export_test.go

@@ -0,0 +1,9 @@
+package flagsmith
+
+// This file exports internal functions for testing purposes only.
+// It is compiled only when running tests (no build tags needed).
+
+// GetUserAgentForTest exposes the getUserAgent function for external tests.
+func GetUserAgentForTest() string {
+	return getUserAgent()
+}

version.go

@@ -0,0 +1,47 @@
+package flagsmith
+
+import (
+	"fmt"
+	"runtime/debug"
+	"strings"
+)
+
+// getUserAgent returns the User-Agent header value in the format "flagsmith-go-sdk/<version>".
+// If the version cannot be determined (e.g., during development), it returns "flagsmith-go-sdk/unknown".
+func getUserAgent() string {
+	const sdkName = "flagsmith-go-sdk"
+	const unknownVersion = "unknown"
+	const modulePrefix = "github.com/Flagsmith/flagsmith-go-client"
+
+	info, ok := debug.ReadBuildInfo()
+	if !ok {
+		return fmt.Sprintf("%s/%s", sdkName, unknownVersion)
+	}
+
+	// Check if SDK module path matches (supports any major version: v4, v5, etc.)
+	isSDKModule := func(path string) bool {
+		return strings.HasPrefix(path, modulePrefix+"/")
+	}
+
+	// If this is the main module (running tests or examples from within the SDK repo),
+	// use the main module version
+	if isSDKModule(info.Main.Path) {
+		version := info.Main.Version
+		if version != "" && version != "(devel)" {
+			return fmt.Sprintf("%s/%s", sdkName, version)
+		}
+	}
+
+	// Otherwise, look for the SDK in the dependencies (when used as a library)
+	for _, dep := range info.Deps {
+		if isSDKModule(dep.Path) {
+			version := dep.Version
+			if version != "" && version != "(devel)" {
+				return fmt.Sprintf("%s/%s", sdkName, version)
+			}
+			break
+		}
+	}
+
+	return fmt.Sprintf("%s/%s", sdkName, unknownVersion)
+}

version_test.go

@@ -0,0 +1,41 @@
+package flagsmith
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetUserAgent(t *testing.T) {
+	// Given/When
+	userAgent := getUserAgent()
+
+	// Then - should return a non-empty string
+	assert.NotEmpty(t, userAgent, "User-Agent should not be empty")
+}
+
+func TestGetUserAgentFormat(t *testing.T) {
+	// Given/When
+	userAgent := getUserAgent()
+
+	// Then - should start with "flagsmith-go-sdk/"
+	assert.True(t, strings.HasPrefix(userAgent, "flagsmith-go-sdk/"),
+		"User-Agent should start with 'flagsmith-go-sdk/', got: %s", userAgent)
+}
+
+func TestGetUserAgentValidFormats(t *testing.T) {
+	// Given/When
+	userAgent := getUserAgent()
+
+	// Then - should be either a valid version or "unknown"
+	parts := strings.Split(userAgent, "/")
+	assert.Equal(t, 2, len(parts), "User-Agent should have exactly two parts separated by '/'")
+	assert.Equal(t, "flagsmith-go-sdk", parts[0], "First part should be 'flagsmith-go-sdk'")
+
+	// Version part should be either a version string (starting with 'v') or "unknown"
+	versionPart := parts[1]
+	isValid := versionPart == "unknown" || strings.HasPrefix(versionPart, "v")
+	assert.True(t, isValid,
+		"Version should be 'unknown' or start with 'v', got: %s", versionPart)
+}