13719232201

Committed 07 Mar 2025 10:57AM UTC coverage: 42.211%. First build

Build # 13719232201

Build Type

Pull #1990

github

Committed by

kemingy

Commit Message

fix ci

Signed-off-by: Keming <kemingyang@tensorchord.ai>

Pull Request Pull Request #1990: feat: support uv

Run Details

44 of 52 new or added lines in 6 files covered. (84.62%)

5075 of 12023 relevant lines covered (42.21%)

159.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/pkg/metrics/docker_collector.go

// Copyright 2023 The envd Authors
//
// 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.

package metrics

import (
        "context"

        "github.com/sirupsen/logrus"

        "github.com/tensorchord/envd/pkg/driver"
)

type dockerCollector struct {
        Metrics
        client        driver.Client
        running       bool
        metricsStream chan Metrics
        done          chan bool
        lastCpu       float64
        lastSysCpu    float64
}

func NewDockerCollector(client driver.Client) Collector {
        return &dockerCollector{
                client: client,
        }
}

func (c *dockerCollector) Stop() error {
        c.done <- true
        return nil
}

func (c *dockerCollector) Watch(ctx context.Context, cid string) chan Metrics {
        if c.running {
                return c.metricsStream
        }
        c.metricsStream = make(chan Metrics)
        c.running = true
        c.done = make(chan bool)
        stats := make(chan *driver.Stats)
        go func() {
                defer close(stats)
                err := c.client.Stats(ctx, cid, stats, c.done)
                if err != nil {
                        logrus.WithField("cid", cid).
                                WithError(err).Error("error occurred in dockerCollector.Watch")
                }
                c.running = false
        }()
        go func() {
                defer close(c.metricsStream)
                for s := range stats {
                        c.ReadCPU(s)
                        c.ReadMem(s)
                        c.ReadNet(s)
                        c.ReadIO(s)
                        c.metricsStream <- c.Metrics
                }
        }()

        return c.metricsStream
}

func (c *dockerCollector) ReadCPU(stats *driver.Stats) {
        ncpus := uint8(stats.CPUStats.OnlineCPUs)
        if ncpus == 0 {
                ncpus = uint8(len(stats.CPUStats.CPUUsage.PercpuUsage))
        }
        total := float64(stats.CPUStats.CPUUsage.TotalUsage)
        system := float64(stats.CPUStats.SystemCPUUsage)

        cpudiff := total - c.lastCpu
        syscpudiff := system - c.lastSysCpu

        c.NCpus = ncpus
        c.CPUUtil = percent(cpudiff, syscpudiff)
        c.lastCpu = total
        c.lastSysCpu = system
        c.Pids = int(stats.PidsStats.Current)
}

func (c *dockerCollector) ReadMem(stats *driver.Stats) {
        c.MemUsage = int64(stats.MemoryStats.Usage - stats.MemoryStats.Stats.Cache)
        c.MemLimit = int64(stats.MemoryStats.Limit)
        c.MemPercent = percent(float64(c.MemUsage), float64(c.MemLimit))
}

func (c *dockerCollector) ReadNet(stats *driver.Stats) {
        var rx, tx int64
        for _, network := range stats.Networks {
                rx += int64(network.RxBytes)
                tx += int64(network.TxBytes)
        }
        c.NetRx, c.NetTx = rx, tx
}

func (c *dockerCollector) ReadIO(stats *driver.Stats) {
        var read, write int64
        for _, blk := range stats.BlkioStats.IOServiceBytesRecursive {
                if blk.Op == "Read" {
                        read += int64(blk.Value)
                }
                if blk.Op == "Write" {
                        write += int64(blk.Value)
                }
        }
        c.IOBytesRead, c.IOBytesWrite = read, write
}

1	// Copyright 2023 The envd Authors
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package metrics
16
17	import (
18	"context"
19
20	"github.com/sirupsen/logrus"
21
22	"github.com/tensorchord/envd/pkg/driver"
23	)
24
25	type dockerCollector struct {
26	Metrics
27	client driver.Client
28	running bool
29	metricsStream chan Metrics
30	done chan bool
31	lastCpu float64
32	lastSysCpu float64
33	}
34
35	func NewDockerCollector(client driver.Client) Collector {	×
36	return &dockerCollector{	×
37	client: client,	×
38	}	×
39	}	×
40
41	func (c *dockerCollector) Stop() error {	×
42	c.done <- true	×
43	return nil	×
44	}	×
45
46	func (c *dockerCollector) Watch(ctx context.Context, cid string) chan Metrics {	×
47	if c.running {	×
48	return c.metricsStream	×
49	}	×
50	c.metricsStream = make(chan Metrics)	×
51	c.running = true	×
52	c.done = make(chan bool)	×
53	stats := make(chan *driver.Stats)	×
54	go func() {	×
55	defer close(stats)	×
56	err := c.client.Stats(ctx, cid, stats, c.done)	×
57	if err != nil {	×
58	logrus.WithField("cid", cid).	×
NEW 59	WithError(err).Error("error occurred in dockerCollector.Watch")	×
60	}	×
61	c.running = false	×
62	}()
63	go func() {	×
64	defer close(c.metricsStream)	×
65	for s := range stats {	×
66	c.ReadCPU(s)	×
67	c.ReadMem(s)	×
68	c.ReadNet(s)	×
69	c.ReadIO(s)	×
70	c.metricsStream <- c.Metrics	×
71	}	×
72	}()
73
74	return c.metricsStream	×
75	}
76
77	func (c dockerCollector) ReadCPU(stats driver.Stats) {	×
78	ncpus := uint8(stats.CPUStats.OnlineCPUs)	×
79	if ncpus == 0 {	×
80	ncpus = uint8(len(stats.CPUStats.CPUUsage.PercpuUsage))	×
81	}	×
82	total := float64(stats.CPUStats.CPUUsage.TotalUsage)	×
83	system := float64(stats.CPUStats.SystemCPUUsage)	×
84		×
85	cpudiff := total - c.lastCpu	×
86	syscpudiff := system - c.lastSysCpu	×
87		×
88	c.NCpus = ncpus	×
89	c.CPUUtil = percent(cpudiff, syscpudiff)	×
90	c.lastCpu = total	×
91	c.lastSysCpu = system	×
92	c.Pids = int(stats.PidsStats.Current)	×
93	}
94
95	func (c dockerCollector) ReadMem(stats driver.Stats) {	×
96	c.MemUsage = int64(stats.MemoryStats.Usage - stats.MemoryStats.Stats.Cache)	×
97	c.MemLimit = int64(stats.MemoryStats.Limit)	×
98	c.MemPercent = percent(float64(c.MemUsage), float64(c.MemLimit))	×
99	}	×
100
101	func (c dockerCollector) ReadNet(stats driver.Stats) {	×
102	var rx, tx int64	×
103	for _, network := range stats.Networks {	×
104	rx += int64(network.RxBytes)	×
105	tx += int64(network.TxBytes)	×
106	}	×
107	c.NetRx, c.NetTx = rx, tx	×
108	}
109
110	func (c dockerCollector) ReadIO(stats driver.Stats) {	×
111	var read, write int64	×
112	for _, blk := range stats.BlkioStats.IOServiceBytesRecursive {	×
113	if blk.Op == "Read" {	×
114	read += int64(blk.Value)	×
115	}	×
116	if blk.Op == "Write" {	×
117	write += int64(blk.Value)	×
118	}	×
119	}
120	c.IOBytesRead, c.IOBytesWrite = read, write	×
121	}

tensorchord / envd / 13719232201

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous