id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c167600 | msg: fmt.Sprintf("exceeded sample limit (%d)", sampleLimit),
status: http.StatusBadRequest,
}
}
ts, val := iter.At()
samples = append(samples, prompb.Sample{
Timestamp: ts,
Value: val,
})
}
if err := iter.Err(); err != nil {
return nil, err
}
resp.Timeseries = append(re... | |
c167601 | }
series = append(series, &concreteSeries{
labels: labels,
samples: ts.Samples,
})
}
sort.Sort(byLabel(series))
return &concreteSeriesSet{
series: series,
}
} | |
c167602 | func(n int) bool {
return c.series.samples[n].Timestamp >= t
})
return c.cur < len(c.series.samples)
} | |
c167603 | := c.series.samples[c.cur]
return s.Timestamp, s.Value
} | |
c167604 |
return c.cur < len(c.series.samples)
} | |
c167605 | newSampleRing(delta, 16),
delta: delta,
}
bit.Reset(it)
return bit
} | |
c167606 | true
b.buf.reset()
b.buf.delta = b.delta
it.Next()
} | |
c167607 | return b.buf.reduceDelta(delta)
} | |
c167608 | float64, ok bool) {
return b.buf.nthLast(n)
} | |
c167609 | b.lastTime, _ = b.Values()
}
if b.lastTime >= t {
return true
}
for b.Next() {
if b.lastTime >= t {
return true
}
}
return false
} | |
c167610 | b.ok = b.it.Next()
if b.ok {
b.lastTime, _ = b.Values()
}
return b.ok
} | |
c167611 | r
r.it.i = -1
return &r.it
} | |
c167612 | l := len(r.buf)
tmin := r.buf[r.i].t - delta
for r.buf[r.f].t < tmin {
r.f++
if r.f >= l {
r.f -= l
}
r.l--
}
return true
} | |
c167613 |
if n > r.l {
return 0, 0, false
}
t, v := r.at(r.l - n)
return t, v, true
} | |
c167614 | (l.state == sLValue || l.state == sMeta2 || l.state == sComment) {
l.i++
if l.i >= len(l.b) {
l.err = io.EOF
return byte(tEOF)
}
}
return l.b[l.i]
} | |
c167615 | Prometheus format does not have units.
return p.l.b[p.offsets[0]:p.offsets[1]], p.text
} | |
c167616 | if strings.IndexByte(s[c:d], byte('\\')) >= 0 {
*l = append(*l, labels.Label{Name: s[a:b], Value: lvalReplacer.Replace(s[c:d])})
continue
}
*l = append(*l, labels.Label{Name: s[a:b], Value: s[c:d]})
}
// Sort labels. We can skip the first entry since the metric name is
// already at the right place.
sor... | |
c167617 | buckets[i] = last
last = b
i++
}
}
buckets[i] = last
return buckets[:i+1]
} | |
c167618 |
fileSD.lock.RUnlock()
}
t.lock.RUnlock()
for filename, timestamp := range uniqueFiles {
ch <- prometheus.MustNewConstMetric(
t.Description,
prometheus.GaugeValue,
timestamp,
filename,
)
}
} | |
c167619 | "Timestamp (mtime) of files read by FileSD. Timestamp is set at read time.",
[]string{"filename"},
nil,
),
discoverers: make(map[*Discovery]struct{}),
}
} | |
c167620 | make(map[string]float64),
logger: logger,
}
fileSDTimeStamp.addDiscoverer(disc)
return disc
} | |
c167621 | level.Error(d.logger).Log("msg", "Error expanding glob", "glob", p, "err", err)
continue
}
paths = append(paths, files...)
}
return paths
} | |
c167622 | > -1 {
p = p[:idx]
} else {
p = "./"
}
if err := d.watcher.Add(p); err != nil {
level.Error(d.logger).Log("msg", "Error adding file watch", "path", p, "err", err)
}
}
} | |
c167623 |
case <-done:
return
}
}
}()
if err := d.watcher.Close(); err != nil {
level.Error(d.logger).Log("msg", "Error closing file watcher", "paths", fmt.Sprintf("%v", d.paths), "err", err)
}
level.Debug(d.logger).Log("msg", "File discovery stopped")
} | |
c167624 | n > m {
level.Debug(d.logger).Log("msg", "file_sd refresh found file that should be removed", "file", f)
d.deleteTimestamp(f)
for i := m; i < n; i++ {
select {
case ch <- []*targetgroup.Group{{Source: fileSource(f, i)}}:
case <-ctx.Done():
return
}
}
}
}
d.lastRefresh = ref
d.wat... | |
c167625 | {
return nil, err
}
case ".yml", ".yaml":
if err := yaml.UnmarshalStrict(content, &targetGroups); err != nil {
return nil, err
}
default:
panic(errors.Errorf("discovery.File.readFile: unhandled file extension %q", ext))
}
for i, tg := range targetGroups {
if tg == nil {
err = errors.New("nil ta... | |
c167626 | fmt.Sprintf("%s:%d", filename, i)
} | |
c167627 | name,
vector: vector,
health: HealthUnknown,
labels: lset,
}
} | |
c167628 | range rule.labels {
if l.Value == "" {
lb.Del(l.Name)
} else {
lb.Set(l.Name, l.Value)
}
}
sample.Metric = lb.Labels()
}
rule.SetHealth(HealthGood)
rule.SetLastError(err)
return vector, nil
} | |
c167629 | defer rule.mtx.Unlock()
rule.evaluationDuration = dur
} | |
c167630 | defer rule.mtx.Unlock()
rule.lastError = err
} | |
c167631 | rule.mtx.Unlock()
return rule.lastError
} | |
c167632 | defer rule.mtx.Unlock()
rule.health = health
} | |
c167633 | defer rule.mtx.Unlock()
return rule.health
} | |
c167634 | defer rule.mtx.Unlock()
return rule.evaluationDuration
} | |
c167635 | href="%s">%s</a>`, pathPrefix+strutil.TableLinkForExpression(ruleExpr), template.HTMLEscapeString(ruleExpr)),
Labels: labels,
}
byt, err := yaml.Marshal(r)
if err != nil {
return template.HTML(fmt.Sprintf("error marshaling recording rule: %q", template.HTMLEscapeString(err.Error())))
}
return template.HTML(... | |
c167636 | r.mutex.Unlock()
return r.lastRate
} | |
c167637 | r.interval.Seconds()
r.mutex.Lock()
defer r.mutex.Unlock()
if r.init {
r.lastRate += r.alpha * (instantRate - r.lastRate)
} else {
r.init = true
r.lastRate = instantRate
}
} | |
c167638 | atomic.AddInt64(&r.newEvents, incr)
} | |
c167639 |
DeleteFunc: func(o interface{}) {
eventCount.WithLabelValues("node", "delete").Inc()
n.enqueue(o)
},
UpdateFunc: func(_, o interface{}) {
eventCount.WithLabelValues("node", "update").Inc()
n.enqueue(o)
},
})
return n
} | |
c167640 | fmt.Fprintln(os.Stderr, " FAILED:", err)
failed = true
} else {
fmt.Printf(" SUCCESS: %d rules found\n", n)
}
fmt.Println()
}
}
if failed {
return 1
}
return 0
} | |
c167641 | FAILED:")
for _, e := range errs {
fmt.Fprintln(os.Stderr, e.Error())
}
failed = true
} else {
fmt.Printf(" SUCCESS: %d rules found\n", n)
}
fmt.Println()
}
if failed {
return 1
}
return 0
} | |
c167642 | {
fmt.Fprintln(os.Stderr, p.Metric, p.Text)
}
if len(problems) > 0 {
return 3
}
return 0
} | |
c167643 | v1.NewAPI(c)
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
val, err := api.Query(ctx, query, time.Now())
cancel()
if err != nil {
fmt.Fprintln(os.Stderr, "query error:", err)
return 1
}
p.printValue(val)
return 0
} | |
c167644 |
stime, err = parseTime(start)
if err != nil {
fmt.Fprintln(os.Stderr, "error parsing start time:", err)
}
}
if !stime.Before(etime) {
fmt.Fprintln(os.Stderr, "start time is not before end time")
}
if step == 0 {
resolution := math.Max(math.Floor(etime.Sub(stime).Seconds()/250), 1)
// Convert secon... | |
c167645 | {
fmt.Fprintln(os.Stderr, "error parsing end time:", err)
}
}
// Run query against client.
api := v1.NewAPI(c)
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
val, err := api.Series(ctx, matchers, stime, etime)
cancel()
if err != nil {
fmt.Fprintln(os.Stderr, "query error:", err... | |
c167646 | := v1.NewAPI(c)
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
val, err := api.LabelValues(ctx, name)
cancel()
if err != nil {
fmt.Fprintln(os.Stderr, "query error:", err)
return 1
}
p.printLabelValues(val)
return 0
} | |
c167647 | make([]model.LabelSet, 0, len(g.Targets))
for _, t := range g.Targets {
tg.Targets = append(tg.Targets, model.LabelSet{
model.AddressLabel: model.LabelValue(t),
})
}
tg.Labels = g.Labels
return nil
} | |
c167648 | bw = v.(*bufio.Writer)
bw.Reset(pw)
}
go func() {
sw(bw)
bw.Flush()
pw.Close()
streamWriterBufPool.Put(bw)
}()
return pr
} | |
c167649 |
if s == "" {
s = "Unknown Status Code"
}
return s
} | |
c167650 | copyArgs(dst.args, a.args)
} | |
c167651 | s...)
a.ParseBytes(a.buf)
} | |
c167652 | if len(kv.key) > 0 || len(kv.value) > 0 {
a.args, kv = allocArg(a.args)
}
}
a.args = releaseArg(a.args)
} | |
c167653 | a.AppendBytes(a.buf[:0])
return a.buf
} | |
c167654 | > 0 {
dst = AppendQuotedArg(dst, kv.value)
}
}
if i+1 < n {
dst = append(dst, '&')
}
}
return dst
} | |
c167655 | := w.Write(a.QueryString())
return int64(n), err
} | |
c167656 | delAllArgs(a.args, key)
} | |
c167657 | delAllArgs(a.args, b2s(key))
} | |
c167658 |
a.args = appendArg(a.args, key, value, argsHasValue)
} | |
c167659 | appendArg(a.args, b2s(key), value, argsHasValue)
} | |
c167660 | appendArg(a.args, b2s(key), b2s(value), argsHasValue)
} | |
c167661 | appendArg(a.args, key, "", argsNoValue)
} | |
c167662 | appendArg(a.args, b2s(key), "", argsNoValue)
} | |
c167663 | setArg(a.args, key, value, argsHasValue)
} | |
c167664 | setArg(a.args, key, b2s(value), argsHasValue)
} | |
c167665 | setArgBytes(a.args, key, value, argsHasValue)
} | |
c167666 | setArg(a.args, key, "", argsNoValue)
} | |
c167667 | setArg(a.args, b2s(key), "", argsNoValue)
} | |
c167668 | peekArgStr(a.args, key)
} | |
c167669 | peekArgBytes(a.args, key)
} | |
c167670 | {
values = append(values, v)
}
})
return values
} | |
c167671 | return a.PeekMulti(b2s(key))
} | |
c167672 | hasArg(a.args, key)
} | |
c167673 | hasArg(a.args, b2s(key))
} | |
c167674 | -1, ErrNoArgValue
}
return ParseUint(value)
} | |
c167675 | value)
a.SetBytesV(key, bb.B)
bytebufferpool.Put(bb)
} | |
c167676 | a.SetUint(b2s(key), value)
} | |
c167677 | return -1, ErrNoArgValue
}
return ParseUfloat(value)
} | |
c167678 | "1", "t", "T", "true", "TRUE", "True", "y", "yes", "Y", "YES", "Yes":
return true
default:
return false
}
} | |
c167679 |
x1 := hex2intTable[src[i+1]]
if x1 == 16 || x2 == 16 {
dst = append(dst, '%')
} else {
dst = append(dst, x1<<4|x2)
i += 2
}
} else {
dst = append(dst, c)
}
}
return dst
} | |
c167680 | // slow path
var prev int
var sub string
for i, n := 0, len(s); i < n; i++ {
sub = ""
switch s[i] {
case '<':
sub = "<"
case '>':
sub = ">"
case '"':
sub = """
case '\'':
sub = "'"
}
if len(sub) > 0 {
dst = append(dst, s[prev:i]...)
dst = append(dst, sub...)
prev ... | |
c167681 | i++ {
dst = append(dst, '.')
dst = AppendUint(dst, int(ip[i]))
}
return dst
} | |
c167682 | %q", ipStr)
}
v, err := ParseUint(b[:n])
if err != nil {
return dst, fmt.Errorf("cannot parse ipStr %q: %s", ipStr, err)
}
if v > 255 {
return dst, fmt.Errorf("cannot parse ipStr %q: ip part cannot exceed 255: parsed %d", ipStr, v)
}
dst[i] = byte(v)
b = b[n+1:]
}
v, err := ParseUint(b)
if err... | |
c167683 | -1, errUnexpectedTrailingChar
}
return v, err
} | |
c167684 | b = b[1:]
default:
minus = 1
}
vv, err := ParseUint(b)
if err != nil {
return -1, errInvalidFloatExponent
}
return float64(v) * offset * math.Pow10(minus*int(vv)), nil
}
return -1, errUnexpectedFloatChar
}
v = 10*v + uint64(c-'0')
if pointFound {
offset /= 10
}
}... | |
c167685 | c == '_' {
dst = append(dst, c)
} else {
dst = append(dst, '%', hexCharUpper(c>>4), hexCharUpper(c&15))
}
}
return dst
} | |
c167686 |
dst.hash = append(dst.hash[:0], u.hash...)
dst.host = append(dst.host[:0], u.host...)
u.queryArgs.CopyTo(&dst.queryArgs)
dst.parsedQueryArgs = u.parsedQueryArgs
// fullURI and requestURI shouldn't be copied, since they are created
// from scratch on each FullURI() and RequestURI() call.
dst.h = u.h
} | |
c167687 | append(u.hash[:0], hash...)
} | |
c167688 | append(u.hash[:0], hash...)
} | |
c167689 | queryString...)
u.parsedQueryArgs = false
} | |
c167690 | queryString...)
u.parsedQueryArgs = false
} | |
c167691 | path...)
u.path = normalizePath(u.path, u.pathOriginal)
} | |
c167692 | append(u.pathOriginal[:0], path...)
u.path = normalizePath(u.path, u.pathOriginal)
} | |
c167693 | scheme...)
lowercaseBytes(u.scheme)
} | |
c167694 | u.scheme = append(u.scheme[:0], scheme...)
lowercaseBytes(u.scheme)
} | |
c167695 |
// is calculated on each call to FullURI().
// There is no need in u.requestURI = u.requestURI[:0], since requestURI
// is calculated on each call to RequestURI().
u.h = nil
} | |
c167696 | host...)
lowercaseBytes(u.host)
} | |
c167697 | u.host = append(u.host[:0], host...)
lowercaseBytes(u.host)
} | |
c167698 | append(dst, u.queryString...)
}
if len(u.hash) > 0 {
dst = append(dst, '#')
dst = append(dst, u.hash...)
}
u.requestURI = dst
return u.requestURI
} | |
c167699 | return append(dst, u.RequestURI()...)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.