Function collect

cli/command/container/stats_helpers.go:68–181

(ctx context.Context, s *Stats, cli client.ContainerAPIClient, streamStats bool, waitFirst *sync.WaitGroup)

}

func collect(ctx context.Context, s *Stats, cli client.ContainerAPIClient, streamStats bool, waitFirst *sync.WaitGroup) { //nolint:gocyclo
	var getFirst bool

	defer func() {
		// if error happens, and we get nothing of stats, release wait group whatever
		if !getFirst {
			getFirst = true
			waitFirst.Done()
		}
	}()

	response, err := cli.ContainerStats(ctx, s.Container, client.ContainerStatsOptions{
		Stream:                streamStats,
		IncludePreviousSample: !streamStats, // collect previous CPU value for the first result when not streaming.
	})
	if err != nil {
		s.SetError(err)
		return
	}

	u := make(chan error, 1)
	go func() {
		defer response.Body.Close()
		dec := json.NewDecoder(response.Body)
		for {
			if ctx.Err() != nil {
				return
			}
			var v container.StatsResponse
			if err := dec.Decode(&v); err != nil {
				dec = json.NewDecoder(io.MultiReader(dec.Buffered(), response.Body))
				u <- err
				if err == io.EOF {
					break
				}
				time.Sleep(100 * time.Millisecond)
				continue
			}

			// Daemon versions before v29 did not return per-stats OSType;
			// fall back to using the daemon's OSType.
			if v.OSType == "" {
				v.OSType = daemonOSType
			}

			if daemonOSType == "windows" {
				netRx, netTx := calculateNetwork(v.Networks)
				s.SetStatistics(StatsEntry{
					Name:          v.Name,
					ID:            v.ID,
					CPUPercentage: calculateCPUPercentWindows(&v),
					Memory:        float64(v.MemoryStats.PrivateWorkingSet),
					NetworkRx:     netRx,
					NetworkTx:     netTx,
					BlockRead:     float64(v.StorageStats.ReadSizeBytes),
					BlockWrite:    float64(v.StorageStats.WriteSizeBytes),
				})
			} else {