Merge #158219 #158364 #158388 #158518

craig[bot] · dhartunian · dt · craig[bot] · commit 84f0bc29d6c6 · 2025-12-01T22:40:23.000Z
158219: server: add vCPU count to diagnostics and status r=dhartunian a=dhartunian Previously, vCPU was just the OS CPU count as reported by the runtime. This change adds a `GetVCPUs` function that's cgroup aware and uses it to compute a new num_vcpus column on the node status protobuf. This new column is used to display stats on the overview page. Resolves: CRDB-54703 Epic: None Release note (ui change): Previously, we would incorrectly report operating system CPU counts on the DB Console overview page even though the column was labeled `vCPUs`. This change fixes the reporting to measure and report vCPUs correctly using cgroups. This should now reflect reserved compute in Kubernetes and other virtualized environments. 158364: ui/jobs: show pause reasons in jobs UI as warnings r=dt a=dt Previously we only showed 'error' for paused jobs, but pause reasons don't show up in error (at least not since 24.x). This extends the UI to look for them in `running_status`, and also treat pause statuses with added advisory reasons as attention-worth (yellow) warnings instead of grey normal pauses. 158388: cli/demo: start job scheduler right away r=dt a=dt Previously we started it quickly but only in the system tenant. Now we start it quickly in all. Also run it more often. Release note: none. Epic: none. 158518: cloud/azure: default enable caching SDK clients r=dt a=dt This mirrors the default in s3 client handling. Release note: none. Epic: none. Co-authored-by: David Hartunian <davidh@cockroachlabs.com> Co-authored-by: David Taylor <davidt@davidt.io>
diff --git a/docs/generated/http/full.md b/docs/generated/http/full.md
@@ -349,7 +349,8 @@ NodeStatus records the most recent values of metrics for a node.
 | latencies | [NodeStatus.LatenciesEntry](#cockroach.server.serverpb.NodesResponse-cockroach.server.status.statuspb.NodeStatus.LatenciesEntry) | repeated | latencies is a map of nodeIDs to nanoseconds which is the latency between this node and the other node.<br><br>NOTE: this is deprecated and is only set if the min supported       cluster version is >= VersionRPCNetworkStats. | [reserved](#support-status) |
 | activity | [NodeStatus.ActivityEntry](#cockroach.server.serverpb.NodesResponse-cockroach.server.status.statuspb.NodeStatus.ActivityEntry) | repeated | activity is a map of nodeIDs to network statistics from this node to other nodes. | [reserved](#support-status) |
 | total_system_memory | [int64](#cockroach.server.serverpb.NodesResponse-int64) |  | total_system_memory is the total RAM available to the system (or, if detected, the memory available to the cgroup this process is in) in bytes. | [alpha](#support-status) |
-| num_cpus | [int32](#cockroach.server.serverpb.NodesResponse-int32) |  | num_cpus is the number of logical CPUs as reported by the operating system on the host where the `cockroach` process is running. Note that this does not report the number of CPUs actually used by `cockroach`; this parameter is controlled separately. | [alpha](#support-status) |
+| num_cpus | [int32](#cockroach.server.serverpb.NodesResponse-int32) |  | num_cpus is the number of logical CPUs as reported by the operating system on the host where the `cockroach` process is running. This reflects the physical CPU count and does not account for container/cgroup limits. See num_vcpus for container-aware CPU allocation. | [alpha](#support-status) |
+| num_vcpus | [double](#cockroach.server.serverpb.NodesResponse-double) |  | num_vcpus is the number of vCPUs allocated to the process by the container orchestrator (e.g., Kubernetes, Docker) based on cgroup CPU quota/period. This represents the platform CPU allocation and is independent of GOMAXPROCS runtime tuning. Falls back to num_cpus if no container limits are configured. Supports fractional values (e.g., 1.5 for Kubernetes CPU limits like "1500m"). | [alpha](#support-status) |
 
 
 
@@ -501,7 +502,8 @@ NodeStatus records the most recent values of metrics for a node.
 | latencies | [NodeStatus.LatenciesEntry](#cockroach.server.status.statuspb.NodeStatus-cockroach.server.status.statuspb.NodeStatus.LatenciesEntry) | repeated | latencies is a map of nodeIDs to nanoseconds which is the latency between this node and the other node.<br><br>NOTE: this is deprecated and is only set if the min supported       cluster version is >= VersionRPCNetworkStats. | [reserved](#support-status) |
 | activity | [NodeStatus.ActivityEntry](#cockroach.server.status.statuspb.NodeStatus-cockroach.server.status.statuspb.NodeStatus.ActivityEntry) | repeated | activity is a map of nodeIDs to network statistics from this node to other nodes. | [reserved](#support-status) |
 | total_system_memory | [int64](#cockroach.server.status.statuspb.NodeStatus-int64) |  | total_system_memory is the total RAM available to the system (or, if detected, the memory available to the cgroup this process is in) in bytes. | [alpha](#support-status) |
-| num_cpus | [int32](#cockroach.server.status.statuspb.NodeStatus-int32) |  | num_cpus is the number of logical CPUs as reported by the operating system on the host where the `cockroach` process is running. Note that this does not report the number of CPUs actually used by `cockroach`; this parameter is controlled separately. | [alpha](#support-status) |
+| num_cpus | [int32](#cockroach.server.status.statuspb.NodeStatus-int32) |  | num_cpus is the number of logical CPUs as reported by the operating system on the host where the `cockroach` process is running. This reflects the physical CPU count and does not account for container/cgroup limits. See num_vcpus for container-aware CPU allocation. | [alpha](#support-status) |
+| num_vcpus | [double](#cockroach.server.status.statuspb.NodeStatus-double) |  | num_vcpus is the number of vCPUs allocated to the process by the container orchestrator (e.g., Kubernetes, Docker) based on cgroup CPU quota/period. This represents the platform CPU allocation and is independent of GOMAXPROCS runtime tuning. Falls back to num_cpus if no container limits are configured. Supports fractional values (e.g., 1.5 for Kubernetes CPU limits like "1500m"). | [alpha](#support-status) |
 
 
 
@@ -656,6 +658,7 @@ NodeStatus records the most recent values of metrics for a node.
 | activity | [NodeResponse.ActivityEntry](#cockroach.server.serverpb.NodesResponseExternal-cockroach.server.serverpb.NodeResponse.ActivityEntry) | repeated | activity is a map of nodeIDs to network statistics from this node to other nodes. | [reserved](#support-status) |
 | total_system_memory | [int64](#cockroach.server.serverpb.NodesResponseExternal-int64) |  | total_system_memory is the total RAM available to the system (or, if detected, the memory available to the cgroup this process is in) in bytes. | [alpha](#support-status) |
 | num_cpus | [int32](#cockroach.server.serverpb.NodesResponseExternal-int32) |  | num_cpus is the number of logical CPUs as reported by the operating system on the host where the `cockroach` process is running. Note that this does not report the number of CPUs actually used by `cockroach`; this parameter is controlled separately. | [alpha](#support-status) |
+| num_vcpus | [double](#cockroach.server.serverpb.NodesResponseExternal-double) |  | num_vcpus is the number of provisioned vCPUs as reported by cgroups or the operating system. | [reserved](#support-status) |
 
 
 
@@ -914,6 +917,7 @@ NodeStatus records the most recent values of metrics for a node.
 | activity | [NodeResponse.ActivityEntry](#cockroach.server.serverpb.NodeResponse-cockroach.server.serverpb.NodeResponse.ActivityEntry) | repeated | activity is a map of nodeIDs to network statistics from this node to other nodes. | [reserved](#support-status) |
 | total_system_memory | [int64](#cockroach.server.serverpb.NodeResponse-int64) |  | total_system_memory is the total RAM available to the system (or, if detected, the memory available to the cgroup this process is in) in bytes. | [alpha](#support-status) |
 | num_cpus | [int32](#cockroach.server.serverpb.NodeResponse-int32) |  | num_cpus is the number of logical CPUs as reported by the operating system on the host where the `cockroach` process is running. Note that this does not report the number of CPUs actually used by `cockroach`; this parameter is controlled separately. | [alpha](#support-status) |
+| num_vcpus | [double](#cockroach.server.serverpb.NodeResponse-double) |  | num_vcpus is the number of provisioned vCPUs as reported by cgroups or the operating system. | [reserved](#support-status) |
 
 
 
diff --git a/docs/generated/http/nodes-other.md b/docs/generated/http/nodes-other.md
@@ -21,7 +21,8 @@ Support status: [alpha](#support-status)
 | latencies | [NodeStatus.LatenciesEntry](#cockroach.server.status.statuspb.NodeStatus.LatenciesEntry) | repeated | latencies is a map of nodeIDs to nanoseconds which is the latency between this node and the other node.<br><br>NOTE: this is deprecated and is only set if the min supported       cluster version is >= VersionRPCNetworkStats. | [reserved](#support-status) |
 | activity | [NodeStatus.ActivityEntry](#cockroach.server.status.statuspb.NodeStatus.ActivityEntry) | repeated | activity is a map of nodeIDs to network statistics from this node to other nodes. | [reserved](#support-status) |
 | total_system_memory | [int64](#int64) |  | total_system_memory is the total RAM available to the system (or, if detected, the memory available to the cgroup this process is in) in bytes. | [alpha](#support-status) |
-| num_cpus | [int32](#int32) |  | num_cpus is the number of logical CPUs as reported by the operating system on the host where the `cockroach` process is running. Note that this does not report the number of CPUs actually used by `cockroach`; this parameter is controlled separately. | [alpha](#support-status) |
+| num_cpus | [int32](#int32) |  | num_cpus is the number of logical CPUs as reported by the operating system on the host where the `cockroach` process is running. This reflects the physical CPU count and does not account for container/cgroup limits. See num_vcpus for container-aware CPU allocation. | [alpha](#support-status) |
+| num_vcpus | [double](#double) |  | num_vcpus is the number of vCPUs allocated to the process by the container orchestrator (e.g., Kubernetes, Docker) based on cgroup CPU quota/period. This represents the platform CPU allocation and is independent of GOMAXPROCS runtime tuning. Falls back to num_cpus if no container limits are configured. Supports fractional values (e.g., 1.5 for Kubernetes CPU limits like "1500m"). | [alpha](#support-status) |
 
 
 
diff --git a/pkg/cli/democluster/demo_cluster.go b/pkg/cli/democluster/demo_cluster.go
@@ -535,6 +535,15 @@ func (c *transientCluster) startTenantService(
 						InjectedLatencyEnabled: c.latencyEnabled.Load,
 					},
 				},
+				JobsTestingKnobs: &jobs.TestingKnobs{
+					// Allow the scheduler daemon to start earlier in demo.
+					SchedulerDaemonInitialScanDelay: func() time.Duration {
+						return time.Second * 2
+					},
+					SchedulerDaemonScanDelay: func() time.Duration {
+						return time.Second * 5
+					},
+				},
 			},
 		}
 
@@ -563,6 +572,15 @@ func (c *transientCluster) startTenantService(
 							InjectedLatencyEnabled: c.latencyEnabled.Load,
 						},
 					},
+					JobsTestingKnobs: &jobs.TestingKnobs{
+						// Allow the scheduler daemon to start earlier in demo.
+						SchedulerDaemonInitialScanDelay: func() time.Duration {
+							return time.Second * 2
+						},
+						SchedulerDaemonScanDelay: func() time.Duration {
+							return time.Second * 5
+						},
+					},
 				},
 			})
 		if err != nil {
@@ -924,7 +942,10 @@ func (demoCtx *Context) testServerArgsForTransientCluster(
 			JobsTestingKnobs: &jobs.TestingKnobs{
 				// Allow the scheduler daemon to start earlier in demo.
 				SchedulerDaemonInitialScanDelay: func() time.Duration {
-					return time.Second * 15
+					return time.Second * 2
+				},
+				SchedulerDaemonScanDelay: func() time.Duration {
+					return time.Second * 5
 				},
 			},
 		},
diff --git a/pkg/cloud/azure/azure_storage.go b/pkg/cloud/azure/azure_storage.go
@@ -60,7 +60,7 @@ var reuseSession = settings.RegisterBoolSetting(
 	settings.ApplicationLevel,
 	"cloudstorage.azure.session_reuse.enabled",
 	"persist the last opened azure client and re-use it when opening a new client with the same argument (some settings may take 2mins to take effect)",
-	false,
+	true,
 )
 
 // A note on Azure authentication:
diff --git a/pkg/server/api_v2_ranges.go b/pkg/server/api_v2_ranges.go
@@ -50,6 +50,8 @@ type nodeStatus struct {
 	TotalSystemMemory int64 `json:"total_system_memory,omitempty"`
 	// NumCpus is the number of CPUs on this node.
 	NumCpus int32 `json:"num_cpus,omitempty"`
+	// NumVcpus is the number of vCPUs on this node.
+	NumVcpus float64 `json:"num_vcpus,omitempty"`
 	// UpdatedAt is the time at which the node status record was last updated,
 	// in nanoseconds since Unix epoch.
 	UpdatedAt int64 `json:"updated_at,omitempty"`
@@ -128,6 +130,7 @@ func (a *apiV2SystemServer) listNodes(w http.ResponseWriter, r *http.Request) {
 			StoreMetrics:      storeMetrics,
 			TotalSystemMemory: n.TotalSystemMemory,
 			NumCpus:           n.NumCpus,
+			NumVcpus:          n.NumVcpus,
 			UpdatedAt:         n.UpdatedAt,
 			LivenessStatus:    int32(nodes.LivenessByNodeID[n.Desc.NodeID]),
 		})
diff --git a/pkg/server/diagnostics/BUILD.bazel b/pkg/server/diagnostics/BUILD.bazel
@@ -20,6 +20,7 @@ go_library(
         "//pkg/kv",
         "//pkg/roachpb",
         "//pkg/server/diagnostics/diagnosticspb",
+        "//pkg/server/status",
         "//pkg/server/status/statuspb",
         "//pkg/server/telemetry",
         "//pkg/settings",
diff --git a/pkg/server/diagnostics/diagnostics.go b/pkg/server/diagnostics/diagnostics.go
@@ -15,6 +15,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/ccl/utilccl/licenseccl"
 	"github.com/cockroachdb/cockroach/pkg/roachpb"
 	"github.com/cockroachdb/cockroach/pkg/server/diagnostics/diagnosticspb"
+	"github.com/cockroachdb/cockroach/pkg/server/status"
 	"github.com/cockroachdb/cockroach/pkg/util/cloudinfo"
 	"github.com/cockroachdb/cockroach/pkg/util/envutil"
 	"github.com/cockroachdb/cockroach/pkg/util/log"
@@ -183,6 +184,7 @@ func populateHardwareInfo(ctx context.Context, e *diagnosticspb.Environment) {
 	}
 
 	e.Hardware.Cpu.Numcpu = int32(system.NumCPU())
+	e.Hardware.Cpu.Numvcpu = float32(status.GetVCPUs(ctx))
 	if cpus, err := cpu.InfoWithContext(ctx); err == nil && len(cpus) > 0 {
 		e.Hardware.Cpu.Sockets = int32(len(cpus))
 		c := cpus[0]
diff --git a/pkg/server/diagnostics/diagnosticspb/diagnostics.proto b/pkg/server/diagnostics/diagnosticspb/diagnostics.proto
@@ -109,6 +109,7 @@ message CPUInfo {
   string model = 4; // reported model name e.g. `Intel(R) Core(TM) i7-7920HQ CPU @ 3.10GHz`
   float mhz = 5;  // speed of first cpu e.g. 3100
   repeated string features = 6; // cpu feature flags for first cpu
+  float numvcpu = 7; // container-aware vCPU allocation from cgroup limits
 }
 
 message HardwareInfo {
diff --git a/pkg/server/nodes_response.go b/pkg/server/nodes_response.go
@@ -147,6 +147,7 @@ func nodeStatusToResp(n *statuspb.NodeStatus, hasViewClusterMetadata bool) serve
 		Activity:          activity,
 		TotalSystemMemory: n.TotalSystemMemory,
 		NumCpus:           n.NumCpus,
+		NumVcpus:          n.NumVcpus,
 	}
 
 	if hasViewClusterMetadata {
diff --git a/pkg/server/serverpb/status.proto b/pkg/server/serverpb/status.proto
@@ -298,6 +298,10 @@ message NodeResponse {
   // this parameter is controlled separately.
   // API: PUBLIC ALPHA
   int32 num_cpus = 12;
+
+  // num_vcpus is the number of provisioned vCPUs as reported by
+  // cgroups or the operating system.
+  double num_vcpus = 13;
 }
 
 // RegionsRequest requests all available regions.
diff --git a/pkg/server/status/recorder.go b/pkg/server/status/recorder.go
@@ -666,6 +666,7 @@ func (mr *MetricsRecorder) GenerateNodeStatus(ctx context.Context) *statuspb.Nod
 		Env:               flattenStrings(envutil.GetEnvVarsUsed()),
 		Activity:          activity,
 		NumCpus:           int32(system.NumCPU()),
+		NumVcpus:          GetVCPUs(ctx),
 		TotalSystemMemory: systemMemory,
 	}
 
diff --git a/pkg/server/status/recorder_test.go b/pkg/server/status/recorder_test.go
@@ -686,6 +686,7 @@ func TestMetricsRecorder(t *testing.T) {
 		},
 		TotalSystemMemory: totalMemory,
 		NumCpus:           int32(system.NumCPU()),
+		NumVcpus:          GetVCPUs(context.Background()),
 	}
 
 	// Make sure there is at least one environment variable that will be
diff --git a/pkg/server/status/runtime.go b/pkg/server/status/runtime.go
@@ -27,6 +27,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/util/log"
 	"github.com/cockroachdb/cockroach/pkg/util/log/eventpb"
 	"github.com/cockroachdb/cockroach/pkg/util/metric"
+	"github.com/cockroachdb/cockroach/pkg/util/system"
 	"github.com/cockroachdb/errors"
 	"github.com/elastic/gosigar"
 	"github.com/shirou/gopsutil/v3/cpu"
@@ -999,6 +1000,7 @@ func CGoMemMaybePurge(
 }
 
 var netstatEvery = log.Every(time.Minute)
+var vcpuCgroupEvery = log.Every(time.Hour)
 
 // SampleEnvironment queries the runtime system for various interesting metrics,
 // storing the resulting values in the set of metric gauges maintained by
@@ -1579,3 +1581,26 @@ func GetCPUCapacity() float64 {
 	}
 	return cpuShare
 }
+
+// GetVCPUs returns the number of vCPUs allocated to the process as
+// reported by cgroups. This falls back to the number of CPUs reported
+// by the OS in case of error. Setting of GOMAXPROCS does not affect this
+// value (as opposed to GetCPUCapacity above which is used for internal
+// rebalancing decisions).
+func GetVCPUs(ctx context.Context) float64 {
+	cgroupCPU, err := cgroups.GetCgroupCPU()
+	if err != nil {
+		if vcpuCgroupEvery.ShouldLog() {
+			log.Ops.Warningf(ctx, "unable to read cgroup CPU settings: %v; falling back to OS-reported CPU count", err)
+		}
+		// No cgroup limits configured. Fall back to the number of CPUs reported
+		// by the operating system.
+		return float64(system.NumCPU())
+	}
+	cpuShare := cgroupCPU.CPUShares()
+	if cpuShare == 0 {
+		// No CPU quota set in cgroup. Fall back to OS-reported CPU count.
+		return float64(system.NumCPU())
+	}
+	return cpuShare
+}
diff --git a/pkg/server/status/runtime_test.go b/pkg/server/status/runtime_test.go
@@ -17,6 +17,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/testutils/skip"
 	"github.com/cockroachdb/cockroach/pkg/util/hlc"
 	"github.com/cockroachdb/cockroach/pkg/util/leaktest"
+	"github.com/cockroachdb/cockroach/pkg/util/system"
 	"github.com/kr/pretty"
 	"github.com/shirou/gopsutil/v3/net"
 	"github.com/stretchr/testify/assert"
@@ -421,3 +422,43 @@ TcpExt: b
 		require.Contains(t, err.Error(), "could not parse value")
 	})
 }
+
+func TestGetVCPUs(t *testing.T) {
+	defer leaktest.AfterTest(t)()
+	ctx := context.Background()
+
+	// GetVCPUs should return a positive number. The exact value depends on
+	// whether we're running in a cgroup with CPU limits or not, but in either
+	// case it should be greater than 0.
+	vcpus := GetVCPUs(ctx)
+	require.Greater(t, vcpus, float64(0), "GetVCPUs should return a positive value")
+
+	// GetVCPUs should never return more than systemuNumCPU() in a non-cgroup
+	// environment, but it may return less in a containerized environment.
+	// We can't test the exact value without setting up cgroups, but we can
+	// verify it's reasonable.
+	numCPU := float64(system.NumCPU())
+	require.LessOrEqual(t, vcpus, numCPU, "GetVCPUs should not return more than NumCPU (sanity check)")
+
+	// Verify that GetVCPUs returns a different result than GetCPUCapacity when
+	// GOMAXPROCS is set lower than available CPUs.
+	currentMaxProcs := runtime.GOMAXPROCS(0)
+	if currentMaxProcs > 1 {
+		// Set GOMAXPROCS to 1 temporarily
+		runtime.GOMAXPROCS(1)
+		defer runtime.GOMAXPROCS(currentMaxProcs)
+
+		vcpusWithLowMaxProcs := GetVCPUs(ctx)
+		cpuCapacityWithLowMaxProcs := GetCPUCapacity()
+
+		// GetVCPUs should ignore GOMAXPROCS in non-cgroup environments
+		// (it should still return system.NumCPU())
+		// GetCPUCapacity should respect GOMAXPROCS and return 1
+		require.Equal(t, float64(1), cpuCapacityWithLowMaxProcs,
+			"GetCPUCapacity should respect GOMAXPROCS")
+
+		// GetVCPUs should be >= GetCPUCapacity when GOMAXPROCS is artificially low
+		require.GreaterOrEqual(t, vcpusWithLowMaxProcs, cpuCapacityWithLowMaxProcs,
+			"GetVCPUs should ignore GOMAXPROCS and return cgroup limit or NumCPU")
+	}
+}
diff --git a/pkg/server/status/statuspb/status.proto b/pkg/server/status/statuspb/status.proto
@@ -82,11 +82,19 @@ message NodeStatus {
   int64 total_system_memory = 11;
 
   // num_cpus is the number of logical CPUs as reported by the operating system
-  // on the host where the `cockroach` process is running. Note that
-  // this does not report the number of CPUs actually used by `cockroach`;
-  // this parameter is controlled separately.
+  // on the host where the `cockroach` process is running. This reflects the
+  // physical CPU count and does not account for container/cgroup limits.
+  // See num_vcpus for container-aware CPU allocation.
   // API: PUBLIC ALPHA
   int32 num_cpus = 12;
+
+  // num_vcpus is the number of vCPUs allocated to the process by the container
+  // orchestrator (e.g., Kubernetes, Docker) based on cgroup CPU quota/period.
+  // This represents the platform CPU allocation and is independent of GOMAXPROCS
+  // runtime tuning. Falls back to num_cpus if no container limits are configured.
+  // Supports fractional values (e.g., 1.5 for Kubernetes CPU limits like "1500m").
+  // API: PUBLIC ALPHA
+  double num_vcpus = 13;
 }
 
 // A HealthAlert is an undesired condition detected by a server which should be
diff --git a/pkg/ui/workspaces/cluster-ui/src/jobs/util/jobOptions.tsx b/pkg/ui/workspaces/cluster-ui/src/jobs/util/jobOptions.tsx
diff --git a/pkg/ui/workspaces/cluster-ui/src/jobs/util/jobStatus.tsx b/pkg/ui/workspaces/cluster-ui/src/jobs/util/jobStatus.tsx
diff --git a/pkg/ui/workspaces/cluster-ui/src/jobs/util/progressBar.tsx b/pkg/ui/workspaces/cluster-ui/src/jobs/util/progressBar.tsx
diff --git a/pkg/ui/workspaces/db-console/src/components/tooltip/tooltip.fixtures.ts b/pkg/ui/workspaces/db-console/src/components/tooltip/tooltip.fixtures.ts
diff --git a/pkg/ui/workspaces/db-console/src/views/cluster/containers/nodesOverview/index.tsx b/pkg/ui/workspaces/db-console/src/views/cluster/containers/nodesOverview/index.tsx
diff --git a/pkg/ui/workspaces/db-console/src/views/cluster/containers/nodesOverview/nodesOverview.spec.tsx b/pkg/ui/workspaces/db-console/src/views/cluster/containers/nodesOverview/nodesOverview.spec.tsx

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ var reuseSession = settings.RegisterBoolSetting(`
`60`	`60`	`settings.ApplicationLevel,`
`61`	`61`	`"cloudstorage.azure.session_reuse.enabled",`
`62`	`62`	`"persist the last opened azure client and re-use it when opening a new client with the same argument (some settings may take 2mins to take effect)",`
`63`		`- false,`
	`63`	`+ true,`
`64`	`64`	`)`
`65`	`65`
`66`	`66`	`// A note on Azure authentication:`
Original file line number	Diff line number	Diff line change
`@@ -109,6 +109,7 @@ message CPUInfo {`
`109`	`109`	string model = 4; // reported model name e.g. `Intel(R) Core(TM) i7-7920HQ CPU @ 3.10GHz`
`110`	`110`	`float mhz = 5; // speed of first cpu e.g. 3100`
`111`	`111`	`repeated string features = 6; // cpu feature flags for first cpu`
	`112`	`+ float numvcpu = 7; // container-aware vCPU allocation from cgroup limits`
`112`	`113`	`}`
`113`	`114`
`114`	`115`	`message HardwareInfo {`
Original file line number	Diff line number	Diff line change
`@@ -147,6 +147,7 @@ func nodeStatusToResp(n *statuspb.NodeStatus, hasViewClusterMetadata bool) serve`
`147`	`147`	`Activity: activity,`
`148`	`148`	`TotalSystemMemory: n.TotalSystemMemory,`
`149`	`149`	`NumCpus: n.NumCpus,`
	`150`	`+ NumVcpus: n.NumVcpus,`
`150`	`151`	`}`
`151`	`152`
`152`	`153`	`if hasViewClusterMetadata {`