Implement the new User Agent sent to the update service (#1072)

Signed-off-by: lujunsan <luisjuncaldev@gmail.com>

Author: lujunsan

pkg/api/server.go

@@ -94,23 +94,39 @@ func updateCheckMiddleware() func(next http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			go func() {
-				versionClient := updates.NewVersionClient()
+				component, version, uiReleaseBuild := getComponentAndVersionFromRequest(r)
+				versionClient := updates.NewVersionClientForComponent(component, version, uiReleaseBuild)
+
 				updateChecker, err := updates.NewUpdateChecker(versionClient)
 				if err != nil {
-					logger.Warnf("unable to create update client for API: %s", err)
+					logger.Warnf("unable to create update client for %s: %s", component, err)
 					return
 				}
 
 				err = updateChecker.CheckLatestVersion()
 				if err != nil {
-					logger.Warnf("could not check for updates for API: %s", err)
+					logger.Warnf("could not check for updates for %s: %s", component, err)
 				}
 			}()
 			next.ServeHTTP(w, r)
 		})
 	}
 }
 
+// getComponentAndVersionFromRequest determines the component name, version, and ui release build from the request
+func getComponentAndVersionFromRequest(r *http.Request) (string, string, bool) {
+	clientType := r.Header.Get("X-Client-Type")
+
+	if clientType == "toolhive-studio" {
+		version := r.Header.Get("X-Client-Version")
+		// Checks if the UI is calling from an official release
+		uiReleaseBuild := r.Header.Get("X-Client-Release-Build") == "true"
+		return "UI", version, uiReleaseBuild
+	}
+
+	return "API", "", false
+}
+
 // Serve starts the server on the given address and serves the API.
 // It is assumed that the caller sets up appropriate signal handling.
 // If isUnixSocket is true, address is treated as a UNIX socket path.

pkg/operator/telemetry/telemetry.go

@@ -84,7 +84,7 @@ func NewService(k8sClient client.Client, namespace string) *Service {
 	}
 	return &Service{
 		client:        k8sClient,
-		versionClient: updates.NewVersionClientWithSuffix("operator"),
+		versionClient: updates.NewVersionClientForComponent("operator", "", false),
 		namespace:     namespace,
 	}
 }

pkg/updates/client.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"runtime"
+	"strings"
 	"time"
 
 	"github.com/stacklok/toolhive/pkg/versions"
@@ -17,27 +19,34 @@ type VersionClient interface {
 
 // NewVersionClient creates a new instance of VersionClient.
 func NewVersionClient() VersionClient {
-	return NewVersionClientWithSuffix("")
+	return NewVersionClientForComponent("CLI", "", false)
 }
 
-// NewVersionClientWithSuffix creates a new instance of VersionClient with an optional user agent suffix.
-func NewVersionClientWithSuffix(suffix string) VersionClient {
+// NewVersionClientForComponent creates a new instance of VersionClient for a specific component.
+func NewVersionClientForComponent(component, version string, uiReleaseBuild bool) VersionClient {
 	return &defaultVersionClient{
 		versionEndpoint: defaultVersionAPI,
-		userAgentSuffix: suffix,
+		component:       component,
+		customVersion:   version,
+		uiReleaseBuild:  uiReleaseBuild,
 	}
 }
 
 type defaultVersionClient struct {
 	versionEndpoint string
-	userAgentSuffix string
+	component       string
+	customVersion   string
+	uiReleaseBuild  bool // For the UI component, tracks if the UI is calling from a release build, false otherwise
 }
 
 const (
 	instanceIDHeader  = "X-Instance-ID"
 	userAgentHeader   = "User-Agent"
 	defaultVersionAPI = "https://updates.codegate.ai/api/v1/version"
 	defaultTimeout    = 3 * time.Second
+
+	buildTypeRelease    = "release"
+	buildTypeLocalBuild = "local_build"
 )
 
 // GetLatestVersion sends a GET request to the update API endpoint and returns the version from the response.
@@ -49,19 +58,38 @@ func (d *defaultVersionClient) GetLatestVersion(instanceID string, currentVersio
 		return "", fmt.Errorf("failed to create request: %w", err)
 	}
 
-	// Set headers
-	// Determine user agent based on build type
-	var userAgent string
-	if versions.BuildType == "release" {
-		userAgent = fmt.Sprintf("toolhive/%s", currentVersion)
-	} else {
-		userAgent = fmt.Sprintf("toolhive/development-%s", currentVersion)
+	// Generate user agent in format: toolhive/[component] [vXX] [release/local_build] ([operating_system])
+
+	// Use custom version if set, otherwise use the passed currentVersion
+	version := currentVersion
+	if d.customVersion != "" {
+		version = d.customVersion
 	}
 
-	// Add suffix
-	if d.userAgentSuffix != "" {
-		userAgent += " " + d.userAgentSuffix
+	// Format version with 'v' prefix if it doesn't start with 'v'
+	if !strings.HasPrefix(version, "v") {
+		version = "v" + version
 	}
+
+	buildType := buildTypeLocalBuild
+	if d.component == "UI" {
+		// For UI: only use "release" if both server and UI are release builds
+		if versions.BuildType == buildTypeRelease && d.uiReleaseBuild {
+			buildType = buildTypeRelease
+		}
+	} else {
+		// For other components: use server build type
+		if versions.BuildType == buildTypeRelease {
+			buildType = buildTypeRelease
+		}
+	}
+
+	// Get platform info as OperatingSystem/Architecture
+	platform := fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH)
+
+	// Format: toolhive/[component] [vXX] [release/local_build] ([operating_system])
+	userAgent := fmt.Sprintf("toolhive/%s %s %s (%s)", d.component, version, buildType, platform)
+
 	req.Header.Set(instanceIDHeader, instanceID)
 	req.Header.Set(userAgentHeader, userAgent)
 

pkg/updates/client_test.go

@@ -6,37 +6,61 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestNewVersionClientWithSuffix(t *testing.T) {
+func TestNewVersionClientForComponent(t *testing.T) {
 	t.Parallel()
 	tests := []struct {
-		name     string
-		suffix   string
-		expected string
+		name           string
+		component      string
+		version        string
+		uiReleaseBuild bool
+		expected       string
 	}{
 		{
-			name:     "no suffix",
-			suffix:   "",
-			expected: "",
+			name:           "CLI component",
+			component:      "CLI",
+			version:        "",
+			uiReleaseBuild: false,
+			expected:       "CLI",
 		},
 		{
-			name:     "operator suffix",
-			suffix:   "operator",
-			expected: "operator",
+			name:           "operator component",
+			component:      "operator",
+			version:        "",
+			uiReleaseBuild: false,
+			expected:       "operator",
 		},
 		{
-			name:     "custom suffix",
-			suffix:   "custom",
-			expected: "custom",
+			name:           "UI component with version and release build",
+			component:      "UI",
+			version:        "2.0.0",
+			uiReleaseBuild: true,
+			expected:       "UI",
+		},
+		{
+			name:           "UI component with version and local build",
+			component:      "UI",
+			version:        "2.0.0",
+			uiReleaseBuild: false,
+			expected:       "UI",
+		},
+		{
+			name:           "API component",
+			component:      "API",
+			version:        "",
+			uiReleaseBuild: false,
+			expected:       "API",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			client := NewVersionClientWithSuffix(tt.suffix)
+			client := NewVersionClientForComponent(tt.component, tt.version, tt.uiReleaseBuild)
 			defaultClient, ok := client.(*defaultVersionClient)
 			assert.True(t, ok, "Expected defaultVersionClient type")
-			assert.Equal(t, tt.expected, defaultClient.userAgentSuffix)
+			assert.Equal(t, tt.expected, defaultClient.component)
+			assert.Equal(t, tt.version, defaultClient.customVersion)
+			assert.Equal(t, tt.uiReleaseBuild, defaultClient.uiReleaseBuild)
 		})
 	}
 }