podman

1
// Copyright 2017, OpenCensus 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 trace
16

17
import (
18
	"time"
19
)
20

21
// samplePeriod is the minimum time between accepting spans in a single bucket.
22
const samplePeriod = time.Second
23

24
// defaultLatencies contains the default latency bucket bounds.
25
// TODO: consider defaults, make configurable
26
var defaultLatencies = [...]time.Duration{
27
	10 * time.Microsecond,
28
	100 * time.Microsecond,
29
	time.Millisecond,
30
	10 * time.Millisecond,
31
	100 * time.Millisecond,
32
	time.Second,
33
	10 * time.Second,
34
	time.Minute,
35
}
36

37
// bucket is a container for a set of spans for a particular error code or latency range.
38
type bucket struct {
39
	nextTime  time.Time   // next time we can accept a span
40
	buffer    []*SpanData // circular buffer of spans
41
	nextIndex int         // location next SpanData should be placed in buffer
42
	overflow  bool        // whether the circular buffer has wrapped around
43
}
44

45
func makeBucket(bufferSize int) bucket {
46
	return bucket{
47
		buffer: make([]*SpanData, bufferSize),
48
	}
49
}
50

51
// add adds a span to the bucket, if nextTime has been reached.
52
func (b *bucket) add(s *SpanData) {
53
	if s.EndTime.Before(b.nextTime) {
54
		return
55
	}
56
	if len(b.buffer) == 0 {
57
		return
58
	}
59
	b.nextTime = s.EndTime.Add(samplePeriod)
60
	b.buffer[b.nextIndex] = s
61
	b.nextIndex++
62
	if b.nextIndex == len(b.buffer) {
63
		b.nextIndex = 0
64
		b.overflow = true
65
	}
66
}
67

68
// size returns the number of spans in the bucket.
69
func (b *bucket) size() int {
70
	if b.overflow {
71
		return len(b.buffer)
72
	}
73
	return b.nextIndex
74
}
75

76
// span returns the ith span in the bucket.
77
func (b *bucket) span(i int) *SpanData {
78
	if !b.overflow {
79
		return b.buffer[i]
80
	}
81
	if i < len(b.buffer)-b.nextIndex {
82
		return b.buffer[b.nextIndex+i]
83
	}
84
	return b.buffer[b.nextIndex+i-len(b.buffer)]
85
}
86

87
// resize changes the size of the bucket to n, keeping up to n existing spans.
88
func (b *bucket) resize(n int) {
89
	cur := b.size()
90
	newBuffer := make([]*SpanData, n)
91
	if cur < n {
92
		for i := 0; i < cur; i++ {
93
			newBuffer[i] = b.span(i)
94
		}
95
		b.buffer = newBuffer
96
		b.nextIndex = cur
97
		b.overflow = false
98
		return
99
	}
100
	for i := 0; i < n; i++ {
101
		newBuffer[i] = b.span(i + cur - n)
102
	}
103
	b.buffer = newBuffer
104
	b.nextIndex = 0
105
	b.overflow = true
106
}
107

108
// latencyBucket returns the appropriate bucket number for a given latency.
109
func latencyBucket(latency time.Duration) int {
110
	i := 0
111
	for i < len(defaultLatencies) && latency >= defaultLatencies[i] {
112
		i++
113
	}
114
	return i
115
}
116

117
// latencyBucketBounds returns the lower and upper bounds for a latency bucket
118
// number.
119
//
120
// The lower bound is inclusive, the upper bound is exclusive (except for the
121
// last bucket.)
122
func latencyBucketBounds(index int) (lower time.Duration, upper time.Duration) {
123
	if index == 0 {
124
		return 0, defaultLatencies[index]
125
	}
126
	if index == len(defaultLatencies) {
127
		return defaultLatencies[index-1], 1<<63 - 1
128
	}
129
	return defaultLatencies[index-1], defaultLatencies[index]
130
}
131