coder · EhabY · Jul 10, 2026 · Jul 12, 2026 · Jul 12, 2026 · Jul 12, 2026
diff --git a/agent/agent.go b/agent/agent.go
@@ -58,6 +58,7 @@ import (
 	"github.com/coder/coder/v2/buildinfo"
 	"github.com/coder/coder/v2/cli/gitauth"
 	"github.com/coder/coder/v2/coderd/database/dbtime"
+	"github.com/coder/coder/v2/coderd/idemetadata"
 	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/codersdk/agentsdk"
 	"github.com/coder/coder/v2/codersdk/workspacesdk"
@@ -127,23 +128,14 @@ type Options struct {
 }
 
 type Client interface {
-	ConnectRPC29(ctx context.Context) (
-		proto.DRPCAgentClient29, tailnetproto.DRPCTailnetClient28, error,
+	ConnectRPC211(ctx context.Context) (
+		proto.DRPCAgentClient211, tailnetproto.DRPCTailnetClient28, error,
 	)
-	// ConnectRPC29WithRole is like ConnectRPC29 but sends an explicit
+	// ConnectRPC211WithRole is like ConnectRPC211 but sends an explicit
 	// role query parameter to the server. The workspace agent should
 	// use role "agent" to enable connection monitoring.
-	ConnectRPC29WithRole(ctx context.Context, role string) (
-		proto.DRPCAgentClient29, tailnetproto.DRPCTailnetClient28, error,
-	)
-	ConnectRPC210(ctx context.Context) (
-		proto.DRPCAgentClient210, tailnetproto.DRPCTailnetClient28, error,
-	)
-	// ConnectRPC210WithRole is like ConnectRPC210 but sends an explicit
-	// role query parameter to the server. The workspace agent should
-	// use role "agent" to enable connection monitoring.
-	ConnectRPC210WithRole(ctx context.Context, role string) (
-		proto.DRPCAgentClient210, tailnetproto.DRPCTailnetClient28, error,
+	ConnectRPC211WithRole(ctx context.Context, role string) (
+		proto.DRPCAgentClient211, tailnetproto.DRPCTailnetClient28, error,
 	)
 	tailnet.DERPMapRewriter
 	agentsdk.RefreshableSessionTokenProvider
@@ -426,17 +418,16 @@ func (a *agent) init() {
 		BlockLocalPortForwarding:   a.blockLocalPortForwarding,
 		ReportConnection: func(id uuid.UUID, magicType agentssh.MagicSessionType, ip string) func(code int, reason string) {
 			var connectionType proto.Connection_Type
-			switch magicType {
-			case agentssh.MagicSessionTypeSSH:
+			// The proto enum cannot represent arbitrary session types, so
+			// map by family.
+			switch idemetadata.Family(string(magicType)) {
+			case idemetadata.AppNameSSH:
 				connectionType = proto.Connection_SSH
-			case agentssh.MagicSessionTypeVSCode:
+			case idemetadata.AppNameVSCode:
 				connectionType = proto.Connection_VSCODE
-			case agentssh.MagicSessionTypeJetBrains:
+			case idemetadata.AppNameJetBrains:
 				connectionType = proto.Connection_JETBRAINS
-			case agentssh.MagicSessionTypeUnknown:
-				connectionType = proto.Connection_TYPE_UNSPECIFIED
 			default:
-				a.logger.Error(a.hardCtx, "unhandled magic session type when reporting connection", slog.F("magic_type", magicType))
 				connectionType = proto.Connection_TYPE_UNSPECIFIED
 			}
 
@@ -1177,7 +1168,7 @@ func (a *agent) run() (retErr error) {
 	// ConnectRPC returns the dRPC connection we use for the Agent and Tailnet v2+ APIs.
 	// We pass role "agent" to enable connection monitoring on the server, which tracks
 	// the agent's connectivity state (first_connected_at, last_connected_at, disconnected_at).
-	aAPI, tAPI, err := a.client.ConnectRPC210WithRole(a.hardCtx, "agent")
+	aAPI, tAPI, err := a.client.ConnectRPC211WithRole(a.hardCtx, "agent")
 	if err != nil {
 		return err
 	}
@@ -2163,13 +2154,12 @@ func (a *agent) Collect(ctx context.Context, networkStats map[netlogtype.Connect
 		stats.TxPackets += int64(counts.TxPackets)
 	}
 
-	// The count of active sessions.
-	sshStats := a.sshServer.ConnStats()
-	stats.SessionCountSsh = sshStats.Sessions
-	stats.SessionCountVscode = sshStats.VSCode
-	stats.SessionCountJetbrains = sshStats.JetBrains
-
-	stats.SessionCountReconnectingPty = a.reconnectingPTYServer.ConnCount()
+	// The count of active sessions. The deprecated session_count_* fields
+	// are only populated by older agents.
+	stats.SessionCounts = a.sshServer.ConnStats()
+	if count := a.reconnectingPTYServer.ConnCount(); count > 0 {
+		stats.SessionCounts[idemetadata.AppNameReconnectingPTY] = count
+	}
 
 	// Compute the median connection latency!
 	a.logger.Debug(ctx, "starting peer latency measurement for stats")

diff --git a/agent/agent_test.go b/agent/agent_test.go
@@ -229,7 +229,7 @@ func assertSSHStats(t *testing.T, stats <-chan *proto.Stats) {
 			return false
 		}
 		t.Logf("got stats: ConnectionCount=%d, RxBytes=%d, TxBytes=%d, SessionCountSsh=%d",
-			s.ConnectionCount, s.RxBytes, s.TxBytes, s.SessionCountSsh)
+			s.ConnectionCount, s.RxBytes, s.TxBytes, s.SessionCounts["ssh"])
 		if s.ConnectionCount > 0 {
 			connectionCountSeen = true
 		}
@@ -239,7 +239,7 @@ func assertSSHStats(t *testing.T, stats <-chan *proto.Stats) {
 		if s.TxBytes > 0 {
 			txBytesSeen = true
 		}
-		if s.SessionCountSsh == 1 {
+		if s.SessionCounts["ssh"] == 1 {
 			sessionCountSSHSeen = true
 		}
 		return connectionCountSeen && rxBytesSeen && txBytesSeen && sessionCountSSHSeen
@@ -287,7 +287,7 @@ func TestAgent_Stats_ReconnectingPTY(t *testing.T) {
 		if s.TxBytes > 0 {
 			txBytesSeen = true
 		}
-		if s.SessionCountReconnectingPty == 1 {
+		if s.SessionCounts["reconnecting_pty"] == 1 {
 			sessionCountReconnectingPTYSeen = true
 		}
 		return connectionCountSeen && rxBytesSeen && txBytesSeen && sessionCountReconnectingPTYSeen
@@ -347,11 +347,11 @@ func TestAgent_Stats_Magic(t *testing.T) {
 		require.Eventuallyf(t, func() bool {
 			s, ok := <-stats
 			t.Logf("got stats: ok=%t, ConnectionCount=%d, RxBytes=%d, TxBytes=%d, SessionCountVSCode=%d, ConnectionMedianLatencyMS=%f",
-				ok, s.ConnectionCount, s.RxBytes, s.TxBytes, s.SessionCountVscode, s.ConnectionMedianLatencyMs)
+				ok, s.ConnectionCount, s.RxBytes, s.TxBytes, s.SessionCounts["vscode"], s.ConnectionMedianLatencyMs)
 			return ok &&
 				// Ensure that the connection didn't count as a "normal" SSH session.
 				// This was a special one, so it should be labeled specially in the stats!
-				s.SessionCountVscode == 1 &&
+				s.SessionCounts["vscode"] == 1 &&
 				// Ensure that connection latency is being counted!
 				// If it isn't, it's set to -1.
 				s.ConnectionMedianLatencyMs >= 0
@@ -417,8 +417,8 @@ func TestAgent_Stats_Magic(t *testing.T) {
 		require.Eventuallyf(t, func() bool {
 			s, ok := <-stats
 			t.Logf("got stats with conn open: ok=%t, ConnectionCount=%d, SessionCountJetBrains=%d",
-				ok, s.ConnectionCount, s.SessionCountJetbrains)
-			return ok && s.SessionCountJetbrains == 1
+				ok, s.ConnectionCount, s.SessionCounts["jetbrains"])
+			return ok && s.SessionCounts["jetbrains"] == 1
 		}, testutil.WaitLong, testutil.IntervalFast,
 			"never saw stats with conn open",
 		)
@@ -431,9 +431,9 @@ func TestAgent_Stats_Magic(t *testing.T) {
 		require.Eventuallyf(t, func() bool {
 			s, ok := <-stats
 			t.Logf("got stats after disconnect %t, %d",
-				ok, s.SessionCountJetbrains)
+				ok, s.SessionCounts["jetbrains"])
 			return ok &&
-				s.SessionCountJetbrains == 0
+				s.SessionCounts["jetbrains"] == 0
 		}, testutil.WaitLong, testutil.IntervalFast,
 			"never saw stats after conn closes",
 		)

diff --git a/agent/agentssh/agentssh.go b/agent/agentssh/agentssh.go
@@ -31,6 +31,8 @@ import (
 	"github.com/coder/coder/v2/agent/agentexec"
 	"github.com/coder/coder/v2/agent/agentrsa"
 	"github.com/coder/coder/v2/agent/usershell"
+	"github.com/coder/coder/v2/coderd/idemetadata"
+	"github.com/coder/coder/v2/coderd/util/syncmap"
 	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/pty"
 )
@@ -71,17 +73,16 @@ const (
 	ContainerUserEnvironmentVariable = "CODER_CONTAINER_USER"
 )
 
-// MagicSessionType enums.
+// Well-known magic session types, defined in terms of the canonical app
+// names so the agent and server vocabularies cannot drift.
 const (
-	// MagicSessionTypeUnknown means the session type could not be determined.
-	MagicSessionTypeUnknown MagicSessionType = "unknown"
 	// MagicSessionTypeSSH is the default session type.
-	MagicSessionTypeSSH MagicSessionType = "ssh"
+	MagicSessionTypeSSH MagicSessionType = idemetadata.AppNameSSH
 	// MagicSessionTypeVSCode is set in the SSH config by the VS Code extension to identify itself.
-	MagicSessionTypeVSCode MagicSessionType = "vscode"
+	MagicSessionTypeVSCode MagicSessionType = idemetadata.AppNameVSCode
 	// MagicSessionTypeJetBrains is set in the SSH config by the JetBrains
 	// extension to identify itself.
-	MagicSessionTypeJetBrains MagicSessionType = "jetbrains"
+	MagicSessionTypeJetBrains MagicSessionType = idemetadata.AppNameJetBrains
 )
 
 // BlockedFileTransferCommands contains a list of restricted file transfer commands.
@@ -155,9 +156,9 @@ type Server struct {
 
 	config *Config
 
-	connCountVSCode     atomic.Int64
-	connCountJetBrains  atomic.Int64
-	connCountSSHSession atomic.Int64
+	// connCounts tracks active sessions per session type, with counters
+	// created on demand so any session type reported by a client is counted.
+	connCounts syncmap.Map[string, *atomic.Int64]
 
 	metrics *sshServerMetrics
 }
@@ -232,7 +233,7 @@ func NewServer(ctx context.Context, logger slog.Logger, prometheusRegistry *prom
 		ChannelHandlers: map[string]ssh.ChannelHandler{
 			"direct-tcpip": func(srv *ssh.Server, conn *gossh.ServerConn, newChan gossh.NewChannel, ctx ssh.Context) {
 				// Wrapper is designed to find and track JetBrains Gateway connections.
-				wrapped := NewJetbrainsChannelWatcher(ctx, s.logger, s.config.ReportConnection, newChan, &s.connCountJetBrains)
+				wrapped := NewJetbrainsChannelWatcher(ctx, s.logger, s.config.ReportConnection, newChan, s.getOrCreateConnCounter(MagicSessionTypeJetBrains))
 				ssh.DirectTCPIPHandler(srv, conn, wrapped, ctx)
 			},
 			"direct-streamlocal@openssh.com": func(srv *ssh.Server, conn *gossh.ServerConn, newChan gossh.NewChannel, ctx ssh.Context) {
@@ -324,21 +325,31 @@ func NewServer(ctx context.Context, logger slog.Logger, prometheusRegistry *prom
 	return s, nil
 }
 
-type ConnStats struct {
-	Sessions  int64
-	VSCode    int64
-	JetBrains int64
+// getOrCreateConnCounter returns the active session counter for the given
+// session type, creating it on first use.
+func (s *Server) getOrCreateConnCounter(sessionType MagicSessionType) *atomic.Int64 {
+	if counter, ok := s.connCounts.Load(string(sessionType)); ok {
+		return counter
+	}
+	counter, _ := s.connCounts.LoadOrStore(string(sessionType), &atomic.Int64{})
+	return counter
 }
 
-func (s *Server) ConnStats() ConnStats {
-	return ConnStats{
-		Sessions:  s.connCountSSHSession.Load(),
-		VSCode:    s.connCountVSCode.Load(),
-		JetBrains: s.connCountJetBrains.Load(),
-	}
+// ConnStats returns a snapshot of active sessions per session type,
+// omitting idle types so reports don't grow with every type ever seen.
+func (s *Server) ConnStats() map[string]int64 {
+	stats := make(map[string]int64)
+	s.connCounts.Range(func(key string, value *atomic.Int64) bool {
+		if count := value.Load(); count > 0 {
+			stats[key] = count
+		}
+		return true
+	})
+	return stats
 }
 
-func extractMagicSessionType(env []string) (magicType MagicSessionType, rawType string, filteredEnv []string) {
+func extractMagicSessionType(env []string) (sessionType MagicSessionType, filteredEnv []string) {
+	var rawType string
 	for _, kv := range env {
 		if !strings.HasPrefix(kv, MagicSessionTypeEnvironmentVariable) {
 			continue
@@ -348,19 +359,16 @@ func extractMagicSessionType(env []string) (magicType MagicSessionType, rawType
 		// Keep going, we'll use the last instance of the env.
 	}
 
-	// Always force lowercase checking to be case-insensitive.
-	switch MagicSessionType(strings.ToLower(rawType)) {
-	case MagicSessionTypeVSCode:
-		magicType = MagicSessionTypeVSCode
-	case MagicSessionTypeJetBrains:
-		magicType = MagicSessionTypeJetBrains
-	case "", MagicSessionTypeSSH:
-		magicType = MagicSessionTypeSSH
-	default:
-		magicType = MagicSessionTypeUnknown
+	if rawType == "" {
+		// No magic session type set: this is a plain SSH session.
+		sessionType = MagicSessionTypeSSH
+	} else {
+		// Canonicalize, do not classify: unknown names flow through in
+		// canonical form so new IDEs need no code changes.
+		sessionType = MagicSessionType(idemetadata.Normalize(rawType))
 	}
 
-	return magicType, rawType, slices.DeleteFunc(env, func(kv string) bool {
+	return sessionType, slices.DeleteFunc(env, func(kv string) bool {
 		return strings.HasPrefix(kv, MagicSessionTypeEnvironmentVariable+"=")
 	})
 }
@@ -423,7 +431,7 @@ func (s *Server) sessionHandler(session ssh.Session) {
 	logger.Info(ctx, "handling ssh session")
 
 	env := session.Environ()
-	magicType, magicTypeRaw, env := extractMagicSessionType(env)
+	magicType, env := extractMagicSessionType(env)
 
 	// It's not safe to assume RemoteAddr() returns a non-nil value. slog.F usage is fine because it correctly
 	// handles nil.
@@ -449,19 +457,15 @@ func (s *Server) sessionHandler(session ssh.Session) {
 
 	reportSession := true
 
-	switch magicType {
-	case MagicSessionTypeVSCode:
-		s.connCountVSCode.Add(1)
-		defer s.connCountVSCode.Add(-1)
-	case MagicSessionTypeJetBrains:
+	if idemetadata.Family(string(magicType)) == idemetadata.AppNameJetBrains {
 		// Do nothing here because JetBrains launches hundreds of ssh sessions.
-		// We instead track JetBrains in the single persistent tcp forwarding channel.
+		// We instead track JetBrains in the single persistent tcp forwarding
+		// channel, matched by family to include IDE-specific identifiers.
 		reportSession = false
-	case MagicSessionTypeSSH:
-		s.connCountSSHSession.Add(1)
-		defer s.connCountSSHSession.Add(-1)
-	case MagicSessionTypeUnknown:
-		logger.Warn(ctx, "invalid magic ssh session type specified", slog.F("raw_type", magicTypeRaw))
+	} else {
+		counter := s.getOrCreateConnCounter(magicType)
+		counter.Add(1)
+		defer counter.Add(-1)
 	}
 
 	closeCause := func(_ string) {}

diff --git a/agent/agentssh/metrics.go b/agent/agentssh/metrics.go
@@ -1,9 +1,9 @@
 package agentssh
 
 import (
-	"strings"
-
 	"github.com/prometheus/client_golang/prometheus"
+
+	"github.com/coder/coder/v2/coderd/idemetadata"
 )
 
 type sshServerMetrics struct {
@@ -72,14 +72,7 @@ func newSSHServerMetrics(registerer prometheus.Registerer) *sshServerMetrics {
 }
 
 func magicTypeMetricLabel(magicType MagicSessionType) string {
-	switch magicType {
-	case MagicSessionTypeVSCode:
-	case MagicSessionTypeJetBrains:
-	case MagicSessionTypeSSH:
-	case MagicSessionTypeUnknown:
-	default:
-		magicType = MagicSessionTypeUnknown
-	}
-	// Always be case insensitive
-	return strings.ToLower(string(magicType))
+	// Label by family to keep metric cardinality bounded while arbitrary
+	// session types flow through.
+	return idemetadata.Family(string(magicType))
 }