Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package google-osconfig-agent for
openSUSE:Factory checked in at 2026-10-16 20:10:14
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/google-osconfig-agent (Old)
and /work/SRC/openSUSE:Factory/.google-osconfig-agent.new.3698736 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "google-osconfig-agent"
Fri Oct 16 20:10:14 2026 rev:65 rq:1385178 version:20261015.00
Changes:
--------
---
/work/SRC/openSUSE:Factory/google-osconfig-agent/google-osconfig-agent.changes
2026-10-02 23:07:00.568505664 +0200
+++
/work/SRC/openSUSE:Factory/.google-osconfig-agent.new.3698736/google-osconfig-agent.changes
2026-10-16 20:13:55.317841945 +0200
@@ -1,0 +2,10 @@
+Fri Oct 16 07:16:50 UTC 2026 - John Paul Adrian Glaubitz
<[email protected]>
+
+- Update to version 20261015.00
+ * Add scalibr os benchmarks (#1044)
+- Update github.com/containerd/containerd to v1.7.35 (bsc#1285135,
CVE-2026-95838)
+- Update github.com/moby/sys/user to v0.4.1 (bsc#1284870, CVE-2026-61801)
+- Update golang.org/x/crypto to v0.58.0
+- Update golang.org/x/net to v0.61.0 (bsc#1285283, CVE-2026-78669)
+
+-------------------------------------------------------------------
Old:
----
osconfig-20260928.01.tar.gz
New:
----
osconfig-20261015.00.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ google-osconfig-agent.spec ++++++
--- /var/tmp/diff_new_pack.BBhLco/_old 2026-10-16 20:14:00.233048354 +0200
+++ /var/tmp/diff_new_pack.BBhLco/_new 2026-10-16 20:14:00.236048480 +0200
@@ -19,7 +19,7 @@
%define shortname osconfig
Name: google-osconfig-agent
-Version: 20260928.01
+Version: 20261015.00
Release: 0
Summary: Google Cloud Guest Agent
License: Apache-2.0
++++++ _service ++++++
--- /var/tmp/diff_new_pack.BBhLco/_old 2026-10-16 20:14:00.273050033 +0200
+++ /var/tmp/diff_new_pack.BBhLco/_new 2026-10-16 20:14:00.276050160 +0200
@@ -3,8 +3,8 @@
<param name="url">https://github.com/GoogleCloudPlatform/osconfig</param>
<param name="scm">git</param>
<param name="exclude">.git</param>
- <param name="versionformat">20260928.01</param>
- <param name="revision">20260928.01</param>
+ <param name="versionformat">20261015.00</param>
+ <param name="revision">20261015.00</param>
<param name="changesgenerate">enable</param>
</service>
<service name="recompress" mode="disabled">
@@ -15,9 +15,12 @@
<param name="basename">osconfig</param>
</service>
<service name="go_modules" mode="disabled">
- <param name="archive">osconfig-20260928.01.tar.gz</param>
+ <param name="archive">osconfig-20261015.00.tar.gz</param>
+ <param
name="replace">github.com/containerd/containerd=github.com/containerd/[email protected]</param>
<param
name="replace">github.com/klauspost/compress=github.com/klauspost/[email protected]</param>
- <param
name="replace">golang.org/x/crypto=golang.org/x/[email protected]</param>
+ <param
name="replace">github.com/moby/sys/user=github.com/moby/sys/[email protected]</param>
+ <param
name="replace">golang.org/x/crypto=golang.org/x/[email protected]</param>
+ <param name="replace">golang.org/x/net=golang.org/x/[email protected]</param>
</service>
</services>
++++++ _servicedata ++++++
--- /var/tmp/diff_new_pack.BBhLco/_old 2026-10-16 20:14:00.303051293 +0200
+++ /var/tmp/diff_new_pack.BBhLco/_new 2026-10-16 20:14:00.307051461 +0200
@@ -1,6 +1,6 @@
<servicedata>
<service name="tar_scm">
<param
name="url">https://github.com/GoogleCloudPlatform/osconfig</param>
- <param
name="changesrevision">6cc49b8ba49719102c0e66d035396136b02be5e8</param></service></servicedata>
+ <param
name="changesrevision">f066b81252091d7e3f6be2611600e80aeaff7ce1</param></service></servicedata>
(No newline at EOF)
++++++ osconfig-20260928.01.tar.gz -> osconfig-20261015.00.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/osconfig-20260928.01/packages/trace.go
new/osconfig-20261015.00/packages/trace.go
--- old/osconfig-20260928.01/packages/trace.go 2026-09-28 17:49:49.000000000
+0200
+++ new/osconfig-20261015.00/packages/trace.go 2026-10-15 15:26:07.000000000
+0200
@@ -14,7 +14,7 @@
osInfoProvider osinfo.Provider
}
-// TracingInstalledPackagesProvider creates an InstalledPackagesProvider
decorator that traces the execution time, memory usage, and OS information for
each call.
+// TracingInstalledPackagesProvider creates an InstalledPackagesProvider
decorator that traces the execution time, memory usage, CPU usage, and OS
information for each call.
func TracingInstalledPackagesProvider(tracedProvider
InstalledPackagesProvider, osInfoProvider osinfo.Provider)
InstalledPackagesProvider {
return tracingInstalledPackagesProvider{tracedProvider: tracedProvider,
osInfoProvider: osInfoProvider}
}
@@ -26,8 +26,8 @@
}
ctx, cancel := context.WithCancel(ctx)
- resultChannel := make(chan utiltrace.TraceMemoryResult)
- go utiltrace.TraceMemory(ctx, 100*time.Millisecond, resultChannel)
+ resultChannel := make(chan utiltrace.TraceResult)
+ go utiltrace.Trace(ctx, 100*time.Millisecond, resultChannel)
startTime := time.Now()
pkgs, err := p.tracedProvider.GetInstalledPackages(ctx)
@@ -41,16 +41,19 @@
return pkgs, err
}
-func logTraceResult(ctx context.Context, result utiltrace.TraceMemoryResult,
duration time.Duration, osinfo osinfo.OSInfo) {
+func logTraceResult(ctx context.Context, result utiltrace.TraceResult,
duration time.Duration, osinfo osinfo.OSInfo) {
clog.Debugf(
ctx,
- "GetInstalledPackages: %.3fs, memory %+.2f MB (=%.2f-%.2f),
peak %.2f MB, mean %.2f MB (%d samples), OS: %s@%s, hostname: %s",
+ "GetInstalledPackages: %.3fs, memory %+.2f MB (=%.2f-%.2f),
peak %.2f MB, mean %.2f MB, CPU peak %.1f%%, mean %.1f%%, alloc %.2f MB (%d
samples), OS: %s@%s, hostname: %s",
duration.Seconds(),
result.MemAfterMB-result.MemBeforeMB,
result.MemAfterMB,
result.MemBeforeMB,
result.MemPeakMB,
result.MemMeanMB,
+ result.CPUPeakPercent,
+ result.CPUMeanPercent,
+ result.AllocMB,
result.SampleCount,
osinfo.ShortName,
osinfo.KernelRelease,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/osconfig-20260928.01/packages/trace_test.go
new/osconfig-20261015.00/packages/trace_test.go
--- old/osconfig-20260928.01/packages/trace_test.go 2026-09-28
17:49:49.000000000 +0200
+++ new/osconfig-20261015.00/packages/trace_test.go 2026-10-15
15:26:07.000000000 +0200
@@ -152,3 +152,65 @@
})
}
}
+
+func runGetInstalledPackagesWithScalibr(t *testing.T, extractors []string,
scanRoots, dirsToSkip []string, op osinfo.Provider) (Packages, error) {
+ t.Helper()
+ provider := &scalibrInstalledPackagesProvider{
+ extractors: extractors,
+ osinfoProvider: op,
+ scanRootPaths: scanRoots,
+ dirsToSkip: dirsToSkip,
+ }
+ traced := TracingInstalledPackagesProvider(provider, op)
+ return traced.GetInstalledPackages(context.Background())
+}
+
+// TestTracingInstalledPackagesProvider_Scalibr verifies that
TracingInstalledPackagesProvider
+// works correctly when decorating a scalibrInstalledPackagesProvider.
+func TestTracingInstalledPackagesProvider_Scalibr(t *testing.T) {
+ utiltest.OverrideVariable(t, &ZypperExists, false)
+ virtualRoot := arrangeVirtualRoot(t, "./testdata/debian.dpkg-status",
"/var/lib/dpkg/status")
+
+ wantPkgs := Packages{Deb: []*PkgInfo{
+ {Name: "7zip", Version: "24.09+dfsg-4", Arch: "x86_64", Source:
Source{Name: "7zip", Version: "24.09+dfsg-4"}, Type: "deb", Purl:
"pkg:deb/linux/[email protected]%2Bdfsg-4?arch=amd64"},
+ {Name: "llvm-16", Version: "1:16.0.6-27+build3", Arch:
"x86_64", Source: Source{Name: "llvm-toolchain-16", Version:
"1:16.0.6-27+build3"}, Type: "deb", Purl:
"pkg:deb/linux/llvm-16@1%3A16.0.6-27%2Bbuild3?arch=amd64&source=llvm-toolchain-16"},
+ }}
+
+ tests := []struct {
+ name string
+ extractors []string
+ scanRoots []string
+ dirsToSkip []string
+ op osinfo.Provider
+ wantPkgs Packages
+ wantErr error
+ }{
+ {
+ name: "valid dpkg scan with scalibr, want
packages and nil error",
+ extractors: []string{"os/dpkg"},
+ scanRoots: []string{virtualRoot},
+ dirsToSkip: []string{},
+ op: stubProvider{},
+ wantPkgs: wantPkgs,
+ wantErr: nil,
+ },
+ {
+ name: "invalid extractor with scalibr, want
unknown plugin error",
+ extractors: []string{"invalid/extractor"},
+ scanRoots: []string{virtualRoot},
+ dirsToSkip: []string{},
+ op: stubProvider{},
+ wantPkgs: Packages{},
+ wantErr: errors.New("unknown plugin
\"invalid/extractor\""),
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ gotPkgs, gotErr :=
runGetInstalledPackagesWithScalibr(t, tt.extractors, tt.scanRoots,
tt.dirsToSkip, tt.op)
+
+ utiltest.AssertErrorMatch(t, gotErr, tt.wantErr)
+ utiltest.AssertEquals(t, gotPkgs, tt.wantPkgs)
+ })
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/osconfig-20260928.01/util/utiltrace/utiltrace.go
new/osconfig-20261015.00/util/utiltrace/utiltrace.go
--- old/osconfig-20260928.01/util/utiltrace/utiltrace.go 2026-09-28
17:49:49.000000000 +0200
+++ new/osconfig-20261015.00/util/utiltrace/utiltrace.go 2026-10-15
15:26:07.000000000 +0200
@@ -28,17 +28,47 @@
SampleCount int
}
-// TraceMemory collects memory usage with specified interval until done
channel is closed
-func TraceMemory(ctx context.Context, interval time.Duration, resultChannel
chan TraceMemoryResult) {
+// TraceResult reflects resource usage stats collected by Trace function.
+type TraceResult struct {
+ TraceMemoryResult
+ CPUPeakPercent float64
+ CPUMeanPercent float64
+ Duration time.Duration
+ AllocMB float64
+}
+
+type cpuSample struct {
+ totalCPUTime time.Duration
+ time time.Time
+}
+
+// Trace collects memory and CPU usage with specified interval until ctx is
cancelled.
+func Trace(ctx context.Context, interval time.Duration, resultChannel chan
TraceResult) {
compactMemory()
+ startTime := time.Now()
+
+ var memBefore runtime.MemStats
+ runtime.ReadMemStats(&memBefore)
+
startMB := memoryUsageMB()
- result := TraceMemoryResult{
- MemBeforeMB: startMB,
- MemPeakMB: startMB,
- SampleCount: 1,
+ result := TraceResult{
+ TraceMemoryResult: TraceMemoryResult{
+ MemBeforeMB: startMB,
+ MemPeakMB: startMB,
+ SampleCount: 1,
+ },
}
runningAverageMB := startMB
+ var lastSample cpuSample
+ startCPUTime, err := getCPUTime()
+ if err == nil {
+ lastSample = cpuSample{totalCPUTime: startCPUTime, time:
startTime}
+ }
+
+ var peakCPU, runningAverageCPU float64
+ cpuSampleCount := 0
+
ticker := time.NewTicker(interval)
defer ticker.Stop()
@@ -51,12 +81,55 @@
if result.MemPeakMB < currentMB {
result.MemPeakMB = currentMB
}
+
+ currentCPUTime, err := getCPUTime()
+ now := time.Now()
+ if err == nil && !lastSample.time.IsZero() {
+ timeDelta := now.Sub(lastSample.time).Seconds()
+ cpuDelta := (currentCPUTime -
lastSample.totalCPUTime).Seconds()
+ if timeDelta > 0 {
+ cpuPercent := (cpuDelta / timeDelta) *
100.0
+ cpuSampleCount++
+ runningAverageCPU += (cpuPercent -
runningAverageCPU) / float64(cpuSampleCount)
+ if cpuPercent > peakCPU {
+ peakCPU = cpuPercent
+ }
+ }
+ lastSample = cpuSample{totalCPUTime:
currentCPUTime, time: now}
+ }
case <-ctx.Done():
compactMemory()
+ totalDuration := time.Since(startTime)
+
+ var memAfter runtime.MemStats
+ runtime.ReadMemStats(&memAfter)
+
result.MemAfterMB = memoryUsageMB()
result.MemMeanMB = runningAverageMB
+ result.AllocMB =
float64(memAfter.TotalAlloc-memBefore.TotalAlloc) / 1024 / 1024
+ result.Duration = totalDuration
+
+ if finalCPUTime, err := getCPUTime(); err == nil &&
totalDuration > 0 && !lastSample.time.IsZero() {
+ meanCPU := (finalCPUTime -
startCPUTime).Seconds() / totalDuration.Seconds() * 100.0
+ runningAverageCPU = meanCPU
+ if meanCPU > peakCPU {
+ peakCPU = meanCPU
+ }
+ }
+
+ result.CPUPeakPercent = peakCPU
+ result.CPUMeanPercent = runningAverageCPU
+
resultChannel <- result
return
}
}
}
+
+// TraceMemory collects memory usage with specified interval until done
channel is closed.
+func TraceMemory(ctx context.Context, interval time.Duration, resultChannel
chan TraceMemoryResult) {
+ traceChan := make(chan TraceResult, 1)
+ go Trace(ctx, interval, traceChan)
+ res := <-traceChan
+ resultChannel <- res.TraceMemoryResult
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/osconfig-20260928.01/util/utiltrace/utiltrace_linux.go
new/osconfig-20261015.00/util/utiltrace/utiltrace_linux.go
--- old/osconfig-20260928.01/util/utiltrace/utiltrace_linux.go 1970-01-01
01:00:00.000000000 +0100
+++ new/osconfig-20261015.00/util/utiltrace/utiltrace_linux.go 2026-10-15
15:26:07.000000000 +0200
@@ -0,0 +1,35 @@
+// Copyright 2026 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build linux
+// +build linux
+
+package utiltrace
+
+import (
+ "fmt"
+ "syscall"
+ "time"
+)
+
+// getCPUTime returns total (user + system) CPU time consumed by the process.
+var getCPUTime = func() (time.Duration, error) {
+ var usage syscall.Rusage
+ if err := syscall.Getrusage(syscall.RUSAGE_SELF, &usage); err != nil {
+ return 0, fmt.Errorf("getrusage error: %w", err)
+ }
+ user := time.Duration(usage.Utime.Sec)*time.Second +
time.Duration(usage.Utime.Usec)*time.Microsecond
+ sys := time.Duration(usage.Stime.Sec)*time.Second +
time.Duration(usage.Stime.Usec)*time.Microsecond
+ return user + sys, nil
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/osconfig-20260928.01/util/utiltrace/utiltrace_test.go
new/osconfig-20261015.00/util/utiltrace/utiltrace_test.go
--- old/osconfig-20260928.01/util/utiltrace/utiltrace_test.go 2026-09-28
17:49:49.000000000 +0200
+++ new/osconfig-20261015.00/util/utiltrace/utiltrace_test.go 2026-10-15
15:26:07.000000000 +0200
@@ -84,3 +84,62 @@
}
})
}
+
+func mockCPUAPI(t *testing.T, cpuTimes []time.Duration) {
+ prevGetCPUTime := getCPUTime
+ t.Cleanup(func() { getCPUTime = prevGetCPUTime })
+
+ idx := 0
+ getCPUTime = func() (time.Duration, error) {
+ if len(cpuTimes) == 0 {
+ return 0, nil
+ }
+ if idx < len(cpuTimes) {
+ val := cpuTimes[idx]
+ idx++
+ return val, nil
+ }
+ return cpuTimes[len(cpuTimes)-1], nil
+ }
+}
+
+// TestTrace verifies that Trace collects both memory and CPU metrics
correctly.
+func TestTrace(t *testing.T) {
+ tests := []struct {
+ name string
+ memLevels []float64
+ cpuTimes []time.Duration
+ wantMemPeak float64
+ wantMemMean float64
+ }{
+ {
+ name: "valid levels, want peak and mean tracked",
+ memLevels: []float64{10, 20, 10},
+ cpuTimes: []time.Duration{0, 10 * time.Millisecond,
20 * time.Millisecond},
+ wantMemPeak: 20,
+ wantMemMean: 15,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ ctx, cancel := context.WithCancel(context.Background())
+ mockMemoryAPI(t, tt.memLevels, cancel)
+ mockCPUAPI(t, tt.cpuTimes)
+
+ gotChannel := make(chan TraceResult)
+ go Trace(ctx, time.Millisecond, gotChannel)
+ got := <-gotChannel
+
+ if got.MemPeakMB != tt.wantMemPeak {
+ t.Errorf("MemPeakMB = %v, want %v",
got.MemPeakMB, tt.wantMemPeak)
+ }
+ if got.MemMeanMB != tt.wantMemMean {
+ t.Errorf("MemMeanMB = %v, want %v",
got.MemMeanMB, tt.wantMemMean)
+ }
+ if got.AllocMB < 0 {
+ t.Errorf("AllocMB = %v, want >= 0", got.AllocMB)
+ }
+ })
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/osconfig-20260928.01/util/utiltrace/utiltrace_windows.go
new/osconfig-20261015.00/util/utiltrace/utiltrace_windows.go
--- old/osconfig-20260928.01/util/utiltrace/utiltrace_windows.go
1970-01-01 01:00:00.000000000 +0100
+++ new/osconfig-20261015.00/util/utiltrace/utiltrace_windows.go
2026-10-15 15:26:07.000000000 +0200
@@ -0,0 +1,28 @@
+// Copyright 2026 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+// +build windows
+
+package utiltrace
+
+import (
+ "time"
+)
+
+// getCPUTime returns total CPU time consumed by the process.
+// Stub implementation on Windows.
+var getCPUTime = func() (time.Duration, error) {
+ return 0, nil
+}
++++++ vendor.tar.gz ++++++
/work/SRC/openSUSE:Factory/google-osconfig-agent/vendor.tar.gz
/work/SRC/openSUSE:Factory/.google-osconfig-agent.new.3698736/vendor.tar.gz
differ: char 13, line 1
