_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q167400 | newAzureResourceFromID | validation | func newAzureResourceFromID(id string, logger log.Logger) (azureResource, error) {
// Resource IDs have the following format.
// /subscriptions/SUBSCRIPTION_ID/resourceGroups/RESOURCE_GROUP/providers/PROVIDER/TYPE/NAME
// or if embedded resource then
// /subscriptions/SUBSCRIPTION_ID/resourceGroups/RESOURCE_GROUP/p... | go | {
"resource": ""
} |
q167401 | String | validation | func (t *Timer) String() string {
return fmt.Sprintf("%s: %s", t.name, t.duration)
} | go | {
"resource": ""
} |
q167402 | Swap | validation | func (t Timers) Swap(i, j int) {
t[i], t[j] = t[j], t[i]
} | go | {
"resource": ""
} |
q167403 | String | validation | func (t *TimerGroup) String() string {
timers := byCreationTimeSorter{}
for _, timer := range t.timers {
timers.Timers = append(timers.Timers, timer)
}
sort.Sort(timers)
result := &bytes.Buffer{}
for _, timer := range timers.Timers {
fmt.Fprintf(result, "%s\n", timer)
}
return result.String()
} | go | {
"resource": ""
} |
q167404 | RegisterAdminHandler | validation | func RegisterAdminHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterAdminHandlerClient(ctx, mux, NewAdminClient(conn))
} | go | {
"resource": ""
} |
q167405 | ParseExpr | validation | func ParseExpr(input string) (Expr, error) {
p := newParser(input)
expr, err := p.parseExpr()
if err != nil {
return nil, err
}
err = p.typecheck(expr)
return expr, err
} | go | {
"resource": ""
} |
q167406 | ParseMetric | validation | func ParseMetric(input string) (m labels.Labels, err error) {
p := newParser(input)
defer p.recover(&err)
m = p.metric()
if p.peek().typ != ItemEOF {
p.errorf("could not parse remaining input %.15q...", p.lex.input[p.lex.lastPos:])
}
return m, nil
} | go | {
"resource": ""
} |
q167407 | ParseMetricSelector | validation | func ParseMetricSelector(input string) (m []*labels.Matcher, err error) {
p := newParser(input)
defer p.recover(&err)
name := ""
if t := p.peek().typ; t == ItemMetricIdentifier || t == ItemIdentifier {
name = p.next().val
}
vs := p.VectorSelector(name)
if p.peek().typ != ItemEOF {
p.errorf("could not parse ... | go | {
"resource": ""
} |
q167408 | newParser | validation | func newParser(input string) *parser {
p := &parser{
lex: lex(input),
}
return p
} | go | {
"resource": ""
} |
q167409 | parseExpr | validation | func (p *parser) parseExpr() (expr Expr, err error) {
defer p.recover(&err)
for p.peek().typ != ItemEOF {
if p.peek().typ == ItemComment {
continue
}
if expr != nil {
p.errorf("could not parse remaining input %.15q...", p.lex.input[p.lex.lastPos:])
}
expr = p.expr()
}
if expr == nil {
p.errorf("... | go | {
"resource": ""
} |
q167410 | parseSeriesDesc | validation | func parseSeriesDesc(input string) (labels.Labels, []sequenceValue, error) {
p := newParser(input)
p.lex.seriesDesc = true
return p.parseSeriesDesc()
} | go | {
"resource": ""
} |
q167411 | typecheck | validation | func (p *parser) typecheck(node Node) (err error) {
defer p.recover(&err)
p.checkType(node)
return nil
} | go | {
"resource": ""
} |
q167412 | next | validation | func (p *parser) next() item {
if p.peekCount > 0 {
p.peekCount--
} else {
t := p.lex.nextItem()
// Skip comments.
for t.typ == ItemComment {
t = p.lex.nextItem()
}
p.token[0] = t
}
if p.token[p.peekCount].typ == ItemError {
p.errorf("%s", p.token[p.peekCount].val)
}
return p.token[p.peekCount]
} | go | {
"resource": ""
} |
q167413 | peek | validation | func (p *parser) peek() item {
if p.peekCount > 0 {
return p.token[p.peekCount-1]
}
p.peekCount = 1
t := p.lex.nextItem()
// Skip comments.
for t.typ == ItemComment {
t = p.lex.nextItem()
}
p.token[0] = t
return p.token[0]
} | go | {
"resource": ""
} |
q167414 | errorf | validation | func (p *parser) errorf(format string, args ...interface{}) {
p.error(errors.Errorf(format, args...))
} | go | {
"resource": ""
} |
q167415 | error | validation | func (p *parser) error(err error) {
perr := &ParseErr{
Line: p.lex.lineNumber(),
Pos: p.lex.linePosition(),
Err: err,
}
if strings.Count(strings.TrimSpace(p.lex.input), "\n") == 0 {
perr.Line = 0
}
panic(perr)
} | go | {
"resource": ""
} |
q167416 | expect | validation | func (p *parser) expect(exp ItemType, context string) item {
token := p.next()
if token.typ != exp {
p.errorf("unexpected %s in %s, expected %s", token.desc(), context, exp.desc())
}
return token
} | go | {
"resource": ""
} |
q167417 | expectOneOf | validation | func (p *parser) expectOneOf(exp1, exp2 ItemType, context string) item {
token := p.next()
if token.typ != exp1 && token.typ != exp2 {
p.errorf("unexpected %s in %s, expected %s or %s", token.desc(), context, exp1.desc(), exp2.desc())
}
return token
} | go | {
"resource": ""
} |
q167418 | recover | validation | func (p *parser) recover(errp *error) {
e := recover()
if _, ok := e.(runtime.Error); ok {
// Print the stack trace but do not inhibit the running application.
buf := make([]byte, 64<<10)
buf = buf[:runtime.Stack(buf, false)]
fmt.Fprintf(os.Stderr, "parser panic: %v\n%s", e, buf)
*errp = errUnexpected
} e... | go | {
"resource": ""
} |
q167419 | expr | validation | func (p *parser) expr() Expr {
// Parse the starting expression.
expr := p.unaryExpr()
// Loop through the operations and construct a binary operation tree based
// on the operators' precedence.
for {
// If the next token is not an operator the expression is done.
op := p.peek().typ
if !op.isOperator() {
... | go | {
"resource": ""
} |
q167420 | number | validation | func (p *parser) number(val string) float64 {
n, err := strconv.ParseInt(val, 0, 64)
f := float64(n)
if err != nil {
f, err = strconv.ParseFloat(val, 64)
}
if err != nil {
p.errorf("error parsing number: %s", err)
}
return f
} | go | {
"resource": ""
} |
q167421 | expectType | validation | func (p *parser) expectType(node Node, want ValueType, context string) {
t := p.checkType(node)
if t != want {
p.errorf("expected type %s in %s, got %s", documentedType(want), context, documentedType(t))
}
} | go | {
"resource": ""
} |
q167422 | Appender | validation | func (s *Storage) Appender() (storage.Appender, error) {
return ×tampTracker{
storage: s,
}, nil
} | go | {
"resource": ""
} |
q167423 | Add | validation | func (t *timestampTracker) Add(_ labels.Labels, ts int64, v float64) (uint64, error) {
t.samples++
if ts > t.highestTimestamp {
t.highestTimestamp = ts
}
return 0, nil
} | go | {
"resource": ""
} |
q167424 | AddFast | validation | func (t *timestampTracker) AddFast(l labels.Labels, _ uint64, ts int64, v float64) error {
_, err := t.Add(l, ts, v)
return err
} | go | {
"resource": ""
} |
q167425 | Commit | validation | func (t *timestampTracker) Commit() error {
t.storage.samplesIn.incr(t.samples)
samplesIn.Add(float64(t.samples))
highestTimestamp.Set(float64(t.highestTimestamp / 1000))
return nil
} | go | {
"resource": ""
} |
q167426 | Add | validation | func (p *problems) Add(mf dto.MetricFamily, text string) {
*p = append(*p, Problem{
Metric: mf.GetName(),
Text: text,
})
} | go | {
"resource": ""
} |
q167427 | Lint | validation | func (l *Linter) Lint() ([]Problem, error) {
// TODO(mdlayher): support for protobuf exposition format?
d := expfmt.NewDecoder(l.r, expfmt.FmtText)
var problems []Problem
var mf dto.MetricFamily
for {
if err := d.Decode(&mf); err != nil {
if err == io.EOF {
break
}
return nil, err
}
problems... | go | {
"resource": ""
} |
q167428 | lint | validation | func lint(mf dto.MetricFamily) []Problem {
fns := []func(mf dto.MetricFamily) []Problem{
lintHelp,
lintMetricUnits,
lintCounter,
lintHistogramSummaryReserved,
}
var problems []Problem
for _, fn := range fns {
problems = append(problems, fn(mf)...)
}
// TODO(mdlayher): lint rules for specific metrics t... | go | {
"resource": ""
} |
q167429 | lintHelp | validation | func lintHelp(mf dto.MetricFamily) []Problem {
var problems problems
// Expect all metrics to have help text available.
if mf.Help == nil {
problems.Add(mf, "no help text")
}
return problems
} | go | {
"resource": ""
} |
q167430 | lintMetricUnits | validation | func lintMetricUnits(mf dto.MetricFamily) []Problem {
var problems problems
unit, base, ok := metricUnits(*mf.Name)
if !ok {
// No known units detected.
return nil
}
// Unit is already a base unit.
if unit == base {
return nil
}
problems.Add(mf, fmt.Sprintf("use base unit %q instead of %q", base, unit)... | go | {
"resource": ""
} |
q167431 | lintCounter | validation | func lintCounter(mf dto.MetricFamily) []Problem {
var problems problems
isCounter := mf.GetType() == dto.MetricType_COUNTER
isUntyped := mf.GetType() == dto.MetricType_UNTYPED
hasTotalSuffix := strings.HasSuffix(mf.GetName(), "_total")
switch {
case isCounter && !hasTotalSuffix:
problems.Add(mf, `counter metr... | go | {
"resource": ""
} |
q167432 | Write | validation | func (c *Client) Write(samples model.Samples) error {
conn, err := net.DialTimeout(c.transport, c.address, c.timeout)
if err != nil {
return err
}
defer conn.Close()
var buf bytes.Buffer
for _, s := range samples {
k := pathFromMetric(s.Metric, c.prefix)
t := float64(s.Timestamp.UnixNano()) / 1e9
v := fl... | go | {
"resource": ""
} |
q167433 | New | validation | func New(minSize, maxSize int, factor float64, makeFunc func(int) interface{}) *Pool {
if minSize < 1 {
panic("invalid minimum pool size")
}
if maxSize < 1 {
panic("invalid maximum pool size")
}
if factor < 1 {
panic("invalid factor")
}
var sizes []int
for s := minSize; s <= maxSize; s = int(float64(s) ... | go | {
"resource": ""
} |
q167434 | Get | validation | func (p *Pool) Get(sz int) interface{} {
for i, bktSize := range p.sizes {
if sz > bktSize {
continue
}
b := p.buckets[i].Get()
if b == nil {
b = p.make(bktSize)
}
return b
}
return p.make(sz)
} | go | {
"resource": ""
} |
q167435 | Put | validation | func (p *Pool) Put(s interface{}) {
slice := reflect.ValueOf(s)
if slice.Kind() != reflect.Slice {
panic(fmt.Sprintf("%+v is not a slice", slice))
}
for i, size := range p.sizes {
if slice.Cap() > size {
continue
}
p.buckets[i].Put(slice.Slice(0, 0).Interface())
return
}
} | go | {
"resource": ""
} |
q167436 | TotalSamples | validation | func (m Matrix) TotalSamples() int {
numSamples := 0
for _, series := range m {
numSamples += len(series.Points)
}
return numSamples
} | go | {
"resource": ""
} |
q167437 | Vector | validation | func (r *Result) Vector() (Vector, error) {
if r.Err != nil {
return nil, r.Err
}
v, ok := r.Value.(Vector)
if !ok {
return nil, errors.New("query result is not a Vector")
}
return v, nil
} | go | {
"resource": ""
} |
q167438 | Scalar | validation | func (r *Result) Scalar() (Scalar, error) {
if r.Err != nil {
return Scalar{}, r.Err
}
v, ok := r.Value.(Scalar)
if !ok {
return Scalar{}, errors.New("query result is not a Scalar")
}
return v, nil
} | go | {
"resource": ""
} |
q167439 | NewDiscovery | validation | func NewDiscovery(conf *SDConfig, logger log.Logger) *Discovery {
creds := credentials.NewStaticCredentials(conf.AccessKey, string(conf.SecretKey), "")
if conf.AccessKey == "" && conf.SecretKey == "" {
creds = nil
}
if logger == nil {
logger = log.NewNopLogger()
}
d := &Discovery{
aws: &aws.Config{
Endpo... | go | {
"resource": ""
} |
q167440 | NewQueueManager | validation | func NewQueueManager(logger log.Logger, walDir string, samplesIn *ewmaRate, cfg config.QueueConfig, externalLabels labels.Labels, relabelConfigs []*relabel.Config, client StorageClient, flushDeadline time.Duration) *QueueManager {
if logger == nil {
logger = log.NewNopLogger()
}
name := client.Name()
logger = lo... | go | {
"resource": ""
} |
q167441 | Append | validation | func (t *QueueManager) Append(s []tsdb.RefSample) bool {
type enqueuable struct {
ts prompb.TimeSeries
ref uint64
}
tempSamples := make([]enqueuable, 0, len(s))
t.seriesMtx.Lock()
for _, sample := range s {
// If we have no labels for the series, due to relabelling or otherwise, don't send the sample.
if... | go | {
"resource": ""
} |
q167442 | Start | validation | func (t *QueueManager) Start() {
// Setup the QueueManagers metrics. We do this here rather than in the
// constructor because of the ordering of creating Queue Managers's, stopping them,
// and then starting new ones in storage/remote/storage.go ApplyConfig.
name := t.client.Name()
t.highestSentTimestampMetric = ... | go | {
"resource": ""
} |
q167443 | Stop | validation | func (t *QueueManager) Stop() {
level.Info(t.logger).Log("msg", "Stopping remote storage...")
defer level.Info(t.logger).Log("msg", "Remote storage stopped.")
close(t.quit)
t.wg.Wait()
// Wait for all QueueManager routines to end before stopping shards and WAL watcher. This
// is to ensure we don't end up execut... | go | {
"resource": ""
} |
q167444 | StoreSeries | validation | func (t *QueueManager) StoreSeries(series []tsdb.RefSeries, index int) {
// Lock before any calls to labelsToLabels proto, as that's where string interning is done.
t.seriesMtx.Lock()
defer t.seriesMtx.Unlock()
temp := make(map[uint64][]prompb.Label, len(series))
for _, s := range series {
ls := processExternal... | go | {
"resource": ""
} |
q167445 | processExternalLabels | validation | func processExternalLabels(ls tsdbLabels.Labels, externalLabels labels.Labels) labels.Labels {
i, j, result := 0, 0, make(labels.Labels, 0, len(ls)+len(externalLabels))
for i < len(ls) && j < len(externalLabels) {
if ls[i].Name < externalLabels[j].Name {
result = append(result, labels.Label{
Name: ls[i].Nam... | go | {
"resource": ""
} |
q167446 | start | validation | func (s *shards) start(n int) {
s.mtx.Lock()
defer s.mtx.Unlock()
newQueues := make([]chan prompb.TimeSeries, n)
for i := 0; i < n; i++ {
newQueues[i] = make(chan prompb.TimeSeries, s.qm.cfg.Capacity)
}
s.queues = newQueues
var hardShutdownCtx context.Context
hardShutdownCtx, s.hardShutdown = context.WithC... | go | {
"resource": ""
} |
q167447 | stop | validation | func (s *shards) stop() {
// Attempt a clean shutdown, but only wait flushDeadline for all the shards
// to cleanly exit. As we're doing RPCs, enqueue can block indefinitely.
// We must be able so call stop concurrently, hence we can only take the
// RLock here.
s.mtx.RLock()
close(s.softShutdown)
s.mtx.RUnlock... | go | {
"resource": ""
} |
q167448 | enqueue | validation | func (s *shards) enqueue(ref uint64, sample prompb.TimeSeries) bool {
s.mtx.RLock()
defer s.mtx.RUnlock()
select {
case <-s.softShutdown:
return false
default:
}
shard := uint64(ref) % uint64(len(s.queues))
select {
case <-s.softShutdown:
return false
case s.queues[shard] <- sample:
return true
}
} | go | {
"resource": ""
} |
q167449 | sendSamplesWithBackoff | validation | func (s *shards) sendSamplesWithBackoff(ctx context.Context, samples []prompb.TimeSeries) error {
backoff := s.qm.cfg.MinBackoff
req, highest, err := buildWriteRequest(samples)
if err != nil {
// Failing to build the write request is non-recoverable, since it will
// only error if marshaling the proto to bytes f... | go | {
"resource": ""
} |
q167450 | New | validation | func New(l log.Logger, conf *SDConfig) (*Discovery, error) {
if l == nil {
l = log.NewNopLogger()
}
var (
kcfg *rest.Config
err error
)
if conf.APIServer.URL == nil {
// Use the Kubernetes provided pod service account
// as described in https://kubernetes.io/docs/admin/service-accounts-admin/
kcfg, er... | go | {
"resource": ""
} |
q167451 | compileCORSRegexString | validation | func compileCORSRegexString(s string) (*regexp.Regexp, error) {
r, err := relabel.NewRegexp(s)
if err != nil {
return nil, err
}
return r.Regexp, nil
} | go | {
"resource": ""
} |
q167452 | computeExternalURL | validation | func computeExternalURL(u, listenAddr string) (*url.URL, error) {
if u == "" {
hostname, err := os.Hostname()
if err != nil {
return nil, err
}
_, port, err := net.SplitHostPort(listenAddr)
if err != nil {
return nil, err
}
u = fmt.Sprintf("http://%s:%s/", hostname, port)
}
if startsOrEndsWithQu... | go | {
"resource": ""
} |
q167453 | sendAlerts | validation | func sendAlerts(s sender, externalURL string) rules.NotifyFunc {
return func(ctx context.Context, expr string, alerts ...*rules.Alert) {
var res []*notifier.Alert
for _, alert := range alerts {
a := ¬ifier.Alert{
StartsAt: alert.FiredAt,
Labels: alert.Labels,
Annotations: alert.Annota... | go | {
"resource": ""
} |
q167454 | Validate | validation | func (g *RuleGroups) Validate() (errs []error) {
set := map[string]struct{}{}
for _, g := range g.Groups {
if g.Name == "" {
errs = append(errs, errors.Errorf("Groupname should not be empty"))
}
if _, ok := set[g.Name]; ok {
errs = append(
errs,
errors.Errorf("groupname: \"%s\" is repeated in th... | go | {
"resource": ""
} |
q167455 | Validate | validation | func (r *Rule) Validate() (errs []error) {
if r.Record != "" && r.Alert != "" {
errs = append(errs, errors.Errorf("only one of 'record' and 'alert' must be set"))
}
if r.Record == "" && r.Alert == "" {
errs = append(errs, errors.Errorf("one of 'record' or 'alert' must be set"))
}
if r.Expr == "" {
errs = ap... | go | {
"resource": ""
} |
q167456 | Parse | validation | func Parse(content []byte) (*RuleGroups, []error) {
var groups RuleGroups
if err := yaml.UnmarshalStrict(content, &groups); err != nil {
return nil, []error{err}
}
return &groups, groups.Validate()
} | go | {
"resource": ""
} |
q167457 | ParseFile | validation | func ParseFile(file string) (*RuleGroups, []error) {
b, err := ioutil.ReadFile(file)
if err != nil {
return nil, []error{err}
}
return Parse(b)
} | go | {
"resource": ""
} |
q167458 | TableLinkForExpression | validation | func TableLinkForExpression(expr string) string {
escapedExpression := url.QueryEscape(expr)
return fmt.Sprintf("/graph?g0.expr=%s&g0.tab=1", escapedExpression)
} | go | {
"resource": ""
} |
q167459 | GraphLinkForExpression | validation | func GraphLinkForExpression(expr string) string {
escapedExpression := url.QueryEscape(expr)
return fmt.Sprintf("/graph?g0.expr=%s&g0.tab=0", escapedExpression)
} | go | {
"resource": ""
} |
q167460 | NewFanout | validation | func NewFanout(logger log.Logger, primary Storage, secondaries ...Storage) Storage {
return &fanout{
logger: logger,
primary: primary,
secondaries: secondaries,
}
} | go | {
"resource": ""
} |
q167461 | Close | validation | func (f *fanout) Close() error {
if err := f.primary.Close(); err != nil {
return err
}
// TODO return multiple errors?
var lastErr error
for _, storage := range f.secondaries {
if err := storage.Close(); err != nil {
lastErr = err
}
}
return lastErr
} | go | {
"resource": ""
} |
q167462 | NewMergeQuerier | validation | func NewMergeQuerier(primaryQuerier Querier, queriers []Querier) Querier {
filtered := make([]Querier, 0, len(queriers))
for _, querier := range queriers {
if querier != NoopQuerier() {
filtered = append(filtered, querier)
}
}
setQuerierMap := make(map[SeriesSet]Querier)
failedQueriers := make(map[Querier]... | go | {
"resource": ""
} |
q167463 | Select | validation | func (q *mergeQuerier) Select(params *SelectParams, matchers ...*labels.Matcher) (SeriesSet, Warnings, error) {
seriesSets := make([]SeriesSet, 0, len(q.queriers))
var warnings Warnings
for _, querier := range q.queriers {
set, wrn, err := querier.Select(params, matchers...)
q.setQuerierMap[set] = querier
if w... | go | {
"resource": ""
} |
q167464 | LabelValues | validation | func (q *mergeQuerier) LabelValues(name string) ([]string, error) {
var results [][]string
for _, querier := range q.queriers {
values, err := querier.LabelValues(name)
if err != nil {
return nil, err
}
results = append(results, values)
}
return mergeStringSlices(results), nil
} | go | {
"resource": ""
} |
q167465 | LabelNames | validation | func (q *mergeQuerier) LabelNames() ([]string, error) {
labelNamesMap := make(map[string]struct{})
for _, b := range q.queriers {
names, err := b.LabelNames()
if err != nil {
return nil, errors.Wrap(err, "LabelNames() from Querier")
}
for _, name := range names {
labelNamesMap[name] = struct{}{}
}
}
... | go | {
"resource": ""
} |
q167466 | Close | validation | func (q *mergeQuerier) Close() error {
// TODO return multiple errors?
var lastErr error
for _, querier := range q.queriers {
if err := querier.Close(); err != nil {
lastErr = err
}
}
return lastErr
} | go | {
"resource": ""
} |
q167467 | NewAlertingRule | validation | func NewAlertingRule(
name string, vec promql.Expr, hold time.Duration,
labels, annotations, externalLabels labels.Labels,
restored bool, logger log.Logger,
) *AlertingRule {
el := make(map[string]string, len(externalLabels))
for _, lbl := range externalLabels {
el[lbl.Name] = lbl.Value
}
return &AlertingRule... | go | {
"resource": ""
} |
q167468 | SetLastError | validation | func (r *AlertingRule) SetLastError(err error) {
r.mtx.Lock()
defer r.mtx.Unlock()
r.lastError = err
} | go | {
"resource": ""
} |
q167469 | LastError | validation | func (r *AlertingRule) LastError() error {
r.mtx.Lock()
defer r.mtx.Unlock()
return r.lastError
} | go | {
"resource": ""
} |
q167470 | SetHealth | validation | func (r *AlertingRule) SetHealth(health RuleHealth) {
r.mtx.Lock()
defer r.mtx.Unlock()
r.health = health
} | go | {
"resource": ""
} |
q167471 | Health | validation | func (r *AlertingRule) Health() RuleHealth {
r.mtx.Lock()
defer r.mtx.Unlock()
return r.health
} | go | {
"resource": ""
} |
q167472 | forStateSample | validation | func (r *AlertingRule) forStateSample(alert *Alert, ts time.Time, v float64) promql.Sample {
lb := labels.NewBuilder(r.labels)
for _, l := range alert.Labels {
lb.Set(l.Name, l.Value)
}
lb.Set(labels.MetricName, alertForStateMetricName)
lb.Set(labels.AlertName, r.name)
s := promql.Sample{
Metric: lb.Labels... | go | {
"resource": ""
} |
q167473 | SetEvaluationDuration | validation | func (r *AlertingRule) SetEvaluationDuration(dur time.Duration) {
r.mtx.Lock()
defer r.mtx.Unlock()
r.evaluationDuration = dur
} | go | {
"resource": ""
} |
q167474 | GetEvaluationDuration | validation | func (r *AlertingRule) GetEvaluationDuration() time.Duration {
r.mtx.Lock()
defer r.mtx.Unlock()
return r.evaluationDuration
} | go | {
"resource": ""
} |
q167475 | State | validation | func (r *AlertingRule) State() AlertState {
r.mtx.Lock()
defer r.mtx.Unlock()
maxState := StateInactive
for _, a := range r.active {
if a.State > maxState {
maxState = a.State
}
}
return maxState
} | go | {
"resource": ""
} |
q167476 | ActiveAlerts | validation | func (r *AlertingRule) ActiveAlerts() []*Alert {
var res []*Alert
for _, a := range r.currentAlerts() {
if a.ResolvedAt.IsZero() {
res = append(res, a)
}
}
return res
} | go | {
"resource": ""
} |
q167477 | currentAlerts | validation | func (r *AlertingRule) currentAlerts() []*Alert {
r.mtx.Lock()
defer r.mtx.Unlock()
alerts := make([]*Alert, 0, len(r.active))
for _, a := range r.active {
anew := *a
alerts = append(alerts, &anew)
}
return alerts
} | go | {
"resource": ""
} |
q167478 | refreshTargetGroups | validation | func (a *Adapter) refreshTargetGroups(allTargetGroups map[string][]*targetgroup.Group) {
tempGroups := generateTargetGroups(allTargetGroups)
if !reflect.DeepEqual(a.groups, tempGroups) {
a.groups = tempGroups
err := a.writeOutput()
if err != nil {
level.Error(log.With(a.logger, "component", "sd-adapter")).L... | go | {
"resource": ""
} |
q167479 | writeOutput | validation | func (a *Adapter) writeOutput() error {
arr := mapToArray(a.groups)
b, _ := json.MarshalIndent(arr, "", " ")
dir, _ := filepath.Split(a.output)
tmpfile, err := ioutil.TempFile(dir, "sd-adapter")
if err != nil {
return err
}
defer tmpfile.Close()
_, err = tmpfile.Write(b)
if err != nil {
return err
}
... | go | {
"resource": ""
} |
q167480 | Run | validation | func (a *Adapter) Run() {
go a.manager.Run()
a.manager.StartCustomProvider(a.ctx, a.name, a.disc)
go a.runCustomSD(a.ctx)
} | go | {
"resource": ""
} |
q167481 | NewAdapter | validation | func NewAdapter(ctx context.Context, file string, name string, d discovery.Discoverer, logger log.Logger) *Adapter {
return &Adapter{
ctx: ctx,
disc: d,
groups: make(map[string]*customSD),
manager: discovery.NewManager(ctx, logger),
output: file,
name: name,
logger: logger,
}
} | go | {
"resource": ""
} |
q167482 | NewGroupMetrics | validation | func NewGroupMetrics(reg prometheus.Registerer) *Metrics {
m := &Metrics{
evalDuration: prometheus.NewSummary(
prometheus.SummaryOpts{
Namespace: namespace,
Name: "rule_evaluation_duration_seconds",
Help: "The duration for a rule to execute.",
}),
evalFailures: prometheus.NewCounter(
... | go | {
"resource": ""
} |
q167483 | EngineQueryFunc | validation | func EngineQueryFunc(engine *promql.Engine, q storage.Queryable) QueryFunc {
return func(ctx context.Context, qs string, t time.Time) (promql.Vector, error) {
q, err := engine.NewInstantQuery(q, qs, t)
if err != nil {
return nil, err
}
res := q.Exec(ctx)
if res.Err != nil {
return nil, res.Err
}
sw... | go | {
"resource": ""
} |
q167484 | NewGroup | validation | func NewGroup(name, file string, interval time.Duration, rules []Rule, shouldRestore bool, opts *ManagerOptions) *Group {
metrics := opts.Metrics
if metrics == nil {
metrics = NewGroupMetrics(opts.Registerer)
}
metrics.groupLastEvalTime.WithLabelValues(groupKey(file, name))
metrics.groupLastDuration.WithLabelVa... | go | {
"resource": ""
} |
q167485 | GetEvaluationDuration | validation | func (g *Group) GetEvaluationDuration() time.Duration {
g.mtx.Lock()
defer g.mtx.Unlock()
return g.evaluationDuration
} | go | {
"resource": ""
} |
q167486 | setEvaluationDuration | validation | func (g *Group) setEvaluationDuration(dur time.Duration) {
g.metrics.groupLastDuration.WithLabelValues(groupKey(g.file, g.name)).Set(dur.Seconds())
g.mtx.Lock()
defer g.mtx.Unlock()
g.evaluationDuration = dur
} | go | {
"resource": ""
} |
q167487 | GetEvaluationTimestamp | validation | func (g *Group) GetEvaluationTimestamp() time.Time {
g.mtx.Lock()
defer g.mtx.Unlock()
return g.evaluationTimestamp
} | go | {
"resource": ""
} |
q167488 | setEvaluationTimestamp | validation | func (g *Group) setEvaluationTimestamp(ts time.Time) {
g.metrics.groupLastEvalTime.WithLabelValues(groupKey(g.file, g.name)).Set(float64(ts.UnixNano()) / 1e9)
g.mtx.Lock()
defer g.mtx.Unlock()
g.evaluationTimestamp = ts
} | go | {
"resource": ""
} |
q167489 | evalTimestamp | validation | func (g *Group) evalTimestamp() time.Time {
var (
offset = int64(g.hash() % uint64(g.interval))
now = time.Now().UnixNano()
adjNow = now - offset
base = adjNow - (adjNow % int64(g.interval))
)
return time.Unix(0, base+offset)
} | go | {
"resource": ""
} |
q167490 | CopyState | validation | func (g *Group) CopyState(from *Group) {
g.evaluationDuration = from.evaluationDuration
ruleMap := make(map[string][]int, len(from.rules))
for fi, fromRule := range from.rules {
nameAndLabels := nameAndLabels(fromRule)
l := ruleMap[nameAndLabels]
ruleMap[nameAndLabels] = append(l, fi)
}
for i, rule := ran... | go | {
"resource": ""
} |
q167491 | NewManager | validation | func NewManager(o *ManagerOptions) *Manager {
if o.Metrics == nil {
o.Metrics = NewGroupMetrics(o.Registerer)
}
m := &Manager{
groups: map[string]*Group{},
opts: o,
block: make(chan struct{}),
logger: o.Logger,
}
if o.Registerer != nil {
o.Registerer.MustRegister(m)
}
o.Metrics.iterationsMissed... | go | {
"resource": ""
} |
q167492 | Stop | validation | func (m *Manager) Stop() {
m.mtx.Lock()
defer m.mtx.Unlock()
level.Info(m.logger).Log("msg", "Stopping rule manager...")
for _, eg := range m.groups {
eg.stop()
}
level.Info(m.logger).Log("msg", "Rule manager stopped")
} | go | {
"resource": ""
} |
q167493 | Update | validation | func (m *Manager) Update(interval time.Duration, files []string, externalLabels labels.Labels) error {
m.mtx.Lock()
defer m.mtx.Unlock()
groups, errs := m.LoadGroups(interval, externalLabels, files...)
if errs != nil {
for _, e := range errs {
level.Error(m.logger).Log("msg", "loading groups failed", "err", e... | go | {
"resource": ""
} |
q167494 | LoadGroups | validation | func (m *Manager) LoadGroups(
interval time.Duration, externalLabels labels.Labels, filenames ...string,
) (map[string]*Group, []error) {
groups := make(map[string]*Group)
shouldRestore := !m.restored
for _, fn := range filenames {
rgs, errs := rulefmt.ParseFile(fn)
if errs != nil {
return nil, errs
}
... | go | {
"resource": ""
} |
q167495 | RuleGroups | validation | func (m *Manager) RuleGroups() []*Group {
m.mtx.RLock()
defer m.mtx.RUnlock()
rgs := make([]*Group, 0, len(m.groups))
for _, g := range m.groups {
rgs = append(rgs, g)
}
// Sort rule groups by file, then by name.
sort.Slice(rgs, func(i, j int) bool {
if rgs[i].file != rgs[j].file {
return rgs[i].file < ... | go | {
"resource": ""
} |
q167496 | Rules | validation | func (m *Manager) Rules() []Rule {
m.mtx.RLock()
defer m.mtx.RUnlock()
var rules []Rule
for _, g := range m.groups {
rules = append(rules, g.rules...)
}
return rules
} | go | {
"resource": ""
} |
q167497 | AlertingRules | validation | func (m *Manager) AlertingRules() []*AlertingRule {
m.mtx.RLock()
defer m.mtx.RUnlock()
alerts := []*AlertingRule{}
for _, rule := range m.Rules() {
if alertingRule, ok := rule.(*AlertingRule); ok {
alerts = append(alerts, alertingRule)
}
}
return alerts
} | go | {
"resource": ""
} |
q167498 | Collect | validation | func (m *Manager) Collect(ch chan<- prometheus.Metric) {
for _, g := range m.RuleGroups() {
ch <- prometheus.MustNewConstMetric(groupInterval,
prometheus.GaugeValue,
g.interval.Seconds(),
groupKey(g.file, g.name))
}
} | go | {
"resource": ""
} |
q167499 | NewWALWatcher | validation | func NewWALWatcher(logger log.Logger, name string, writer writeTo, walDir string) *WALWatcher {
if logger == nil {
logger = log.NewNopLogger()
}
return &WALWatcher{
logger: logger,
writer: writer,
walDir: path.Join(walDir, "wal"),
name: name,
quit: make(chan struct{}),
done: make(chan struct{}),
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.