id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c167300 | l.Hash()
ret, ok := enh.sigf[h]
if ok {
return ret
}
ret = f(l)
enh.sigf[h] = ret
return ret
}
} | |
c167301 | Range: subq.Range,
Offset: subq.Offset,
series: make([]storage.Series, 0, len(val)),
}
for _, s := range val {
ms.series = append(ms.series, NewStorageSeries(s))
}
return ms
} | |
c167302 | if !ok || t > refTime {
t, v, ok = it.PeekBack(1)
if !ok || t < refTime-durationMilliseconds(LookbackDelta) {
return 0, 0, false
}
}
if value.IsStaleNaN(v) {
return 0, 0, false
}
return t, v, true
} | |
c167303 | {
return func(lset labels.Labels) uint64 { return lset.HashForLabels(names...) }
}
return func(lset labels.Labels) uint64 { return lset.HashWithoutLabels(names...) }
} | |
c167304 | // Catch cases where the scalar is the LHS in a scalar-vector comparison operation.
// We want to always keep the vector element value as the output value, even if it's on the RHS.
if op.isComparisonOperator() && swap {
value = rv
}
if returnBool {
if keep {
value = 1.0
} else {
value = 0.0
... | |
c167305 | case ItemLSS:
return btos(lhs < rhs)
case ItemGTE:
return btos(lhs >= rhs)
case ItemLTE:
return btos(lhs <= rhs)
}
panic(errors.Errorf("operator %q not allowed for Scalar operations", op))
} | |
c167306 | ItemPOW, ItemMOD:
return true
default:
return false
}
} | |
c167307 | if exists && err == nil {
e.enqueue(obj.(*apiv1.Endpoints))
}
if err != nil {
level.Error(e.logger).Log("msg", "retrieving endpoints failed", "err", err)
}
}
e.serviceInf.AddEventHandler(cache.ResourceEventHandlerFuncs{
// TODO(fabxc): potentially remove add and delete event handlers. Those should
/... | |
c167308 | * (s1 - s0)
y := (1 - tf) * b
return x + y
} | |
c167309 | * x
}
covXY := sumXY - sumX*sumY/n
varX := sumX2 - sumX*sumX/n
slope = covXY / varX
intercept = sumY/n - slope*sumX/n
return slope, intercept
} | |
c167310 | {
t := time.Unix(int64(el.V), 0).UTC()
enh.out = append(enh.out, Sample{
Metric: enh.dropMetricName(el.Metric),
Point: Point{V: f(t)},
})
}
return enh.out
} | |
c167311 | := functions[name]
return function, ok
} | |
c167312 | range c.MarathonSDConfigs {
if cfg == nil {
return errors.New("empty or null section in marathon_sd_configs")
}
}
for _, cfg := range c.NerveSDConfigs {
if cfg == nil {
return errors.New("empty or null section in nerve_sd_configs")
}
}
for _, cfg := range c.OpenstackSDConfigs {
if cfg == nil {
r... | |
c167313 | quit: make(chan struct{}),
seen: map[string]time.Time{},
}
go d.run()
return d
} | |
c167314 | }
d.mtx.Lock()
if len(d.seen) < maxEntries {
d.seen[line] = time.Now()
}
d.mtx.Unlock()
return d.next.Log(keyvals...)
} | |
c167315 | case g.ch <- struct{}{}:
return nil
}
} | |
c167316 | conntrack.DialWithTracing(),
conntrack.DialWithName("triton_sd"),
),
}
client := &http.Client{Transport: transport}
d := &Discovery{
client: client,
interval: time.Duration(conf.RefreshInterval),
sdConfig: conf,
}
d.Discovery = refresh.NewDiscovery(
logger,
"triton",
time.Duration(conf.Refres... | |
c167317 |
defer h.mtx.Unlock()
h.config = conf
return nil
} | |
c167318 | := atomic.LoadUint32(&h.ready)
return ready > 0
} | |
c167319 | http.FileSystem {
return &timefs{fs: fs, t: t}
} | |
c167320 |
switch {
case b == '_':
result.WriteByte('_')
escapeLevel = 0
case b == '.':
result.WriteByte(':')
escapeLevel = 0
case b >= '0' && b <= '9':
parsedByte = (b - 48) << 4
escapeLevel = 2
case b >= 'A' && b <= 'F': // A-F
parsedByte = (b - 55) << 4
escapeLevel = 2
default... | |
c167321 | != nil {
return err
}
points = append(points, p)
}
bps, err := influx.NewBatchPoints(influx.BatchPointsConfig{
Precision: "ms",
Database: c.database,
RetentionPolicy: c.retentionPolicy,
})
if err != nil {
return err
}
bps.AddPoints(points)
return c.client.Write(bps)
} | |
c167322 | {
result = append(result, a[i])
i++
j++
}
}
result = append(result, a[i:]...)
result = append(result, b[j:]...)
return result
} | |
c167323 | <- c.ignoredSamples.Desc()
} | |
c167324 |
client: &http.Client{Transport: rt},
servers: conf.Servers,
appsClient: fetchApps,
}
d.Discovery = refresh.NewDiscovery(
logger,
"marathon",
time.Duration(conf.RefreshInterval),
d.refresh,
)
return d, nil
} | |
c167325 | return &authTokenRoundTripper{token, rt}, nil
} | |
c167326 |
_, err := ioutil.ReadFile(tokenFile)
if err != nil {
return nil, errors.Wrapf(err, "unable to read auth token file %s", tokenFile)
}
return &authTokenFileRoundTripper{tokenFile, rt}, nil
} | |
c167327 | app.Networks[0].Mode == "container"
} | |
c167328 | during marathon service discovery", resp.StatusCode)
}
var apps appList
err = json.NewDecoder(resp.Body).Decode(&apps)
if err != nil {
return nil, errors.Wrapf(err, "%q", url)
}
return &apps, nil
} | |
c167329 | from Marathon at some point.
server := servers[rand.Intn(len(servers))]
return fmt.Sprintf("%s%s", server, appListPath)
} | |
c167330 | group := createTargetGroup(&a)
tgroups[group.Source] = group
}
return tgroups
} | |
c167331 | for the container.
// Note that this host port is likely set to 0 in the app definition, which means it is
// automatically generated and needs to be extracted from the task's 'ports' array at a later stage.
ports[i] = portMappings[i].HostPort
}
}
return ports, labels
} | |
c167332 | DefaultConfig
err := yaml.UnmarshalStrict([]byte(s), cfg)
if err != nil {
return nil, err
}
cfg.original = s
return cfg, nil
} | |
c167333 | "parsing YAML file %s", filename)
}
resolveFilepaths(filepath.Dir(filename), cfg)
return cfg, nil
} | |
c167334 | for _, cfg := range cfg.TritonSDConfigs {
tlsPaths(&cfg.TLSConfig)
}
for _, filecfg := range cfg.FileSDConfigs {
for i, fn := range filecfg.Files {
filecfg.Files[i] = join(fn)
}
}
}
for _, cfg := range cfg.ScrapeConfigs {
clientPaths(&cfg.HTTPClientConfig)
sdPaths(&cfg.ServiceDiscoveryConfig)... | |
c167335 |
c.ScrapeTimeout == 0 &&
c.EvaluationInterval == 0
} | |
c167336 |
return errors.Errorf("%q is not a valid hostname", address)
}
return nil
} | |
c167337 | err
}
cd := &Discovery{
client: client,
tagSeparator: conf.TagSeparator,
watchedServices: conf.Services,
watchedTags: conf.ServiceTags,
watchedNodeMeta: conf.NodeMeta,
allowStale: conf.AllowStale,
refreshInterval: time.Duration(conf.RefreshInterval),
clientDatacenter: conf... | |
c167338 | d.shouldWatchFromName(name) && d.shouldWatchFromTags(tags)
} | |
c167339 | sn := range d.watchedServices {
if sn == name {
return true
}
}
return false
} | |
c167340 | err := errors.Errorf("invalid value '%v' for Config.Datacenter", info["Config"]["Datacenter"])
level.Error(d.logger).Log("msg", "Error retrieving datacenter name", "err", err)
return err
}
d.clientDatacenter = dc
return nil
} | |
c167341 | necessary.
err := d.getDatacenter()
if err != nil {
time.Sleep(retryInterval)
continue
}
// We are good to go.
return
}
} | |
c167342 | have the tag we are looking for (if specified).
// In the future consul will also support server side for service metadata.
// https://github.com/hashicorp/consul/issues/1107
if !d.shouldWatch(name, srvs[name]) {
continue
}
if _, ok := services[name]; ok {
continue // We are already watching the servic... | |
c167343 | var lastIndex uint64
catalog := srv.client.Catalog()
for {
select {
case <-ctx.Done():
ticker.Stop()
return
default:
srv.watch(ctx, ch, catalog, &lastIndex)
<-ticker.C
}
}
}()
} | |
c167344 |
DeleteFunc: func(o interface{}) {
eventCount.WithLabelValues("pod", "delete").Inc()
p.enqueue(o)
},
UpdateFunc: func(_, o interface{}) {
eventCount.WithLabelValues("pod", "update").Inc()
p.enqueue(o)
},
})
return p
} | |
c167345 | + v + ")$")
if err != nil {
return nil, err
}
m.re = re
}
return m, nil
} | |
c167346 | return s != m.Value
case MatchRegexp:
return m.re.MatchString(s)
case MatchNotRegexp:
return !m.re.MatchString(s)
}
panic("labels.Matcher.Matches: invalid match type")
} | |
c167347 | return "promqlPrepare"
case InnerEvalTime:
return "promqlInnerEval"
case ExecQueueTime:
return "promqlExecQueue"
case ExecTotalTime:
return "promqlExec"
default:
return "Unknown query timing"
}
} | |
c167348 | qt.InnerEvalTime = timer.Duration()
case ExecQueueTime:
qt.ExecQueueTime = timer.Duration()
case ExecTotalTime:
qt.ExecTotalTime = timer.Duration()
}
}
qs := QueryStats{Timings: qt}
return &qs
} | |
c167349 | l,
"openstack",
time.Duration(conf.RefreshInterval),
r.refresh,
), nil
} | |
c167350 | err != nil {
return err
}
*ls = FromMap(m)
return nil
} | |
c167351 | b = append(b, v.Name...)
b = append(b, sep)
b = append(b, v.Value...)
b = append(b, sep)
}
return xxhash.Sum64(b)
} | |
c167352 |
if v.Name == n {
b = append(b, v.Name...)
b = append(b, sep)
b = append(b, v.Value...)
b = append(b, sep)
break
}
}
}
return xxhash.Sum64(b)
} | |
c167353 | copy(res, ls)
return res
} | |
c167354 | == name {
return l.Value
}
}
return ""
} | |
c167355 | name {
return true
}
}
return false
} | |
c167356 | if l.Name != o[i].Name || l.Value != o[i].Value {
return false
}
}
return true
} | |
c167357 | l := range ls {
m[l.Name] = l.Value
}
return m
} | |
c167358 | set = append(set, l)
}
sort.Sort(set)
return set
} | |
c167359 |
res = append(res, Label{Name: ss[i], Value: ss[i+1]})
}
sort.Sort(res)
return res
} | |
c167360 | 0, 5),
add: make([]Label, 0, 5),
}
} | |
c167361 | {
if a.Name == n {
b.add = append(b.add[:i], b.add[i+1:]...)
}
}
b.del = append(b.del, n)
}
return b
} | |
c167362 | }
}
for _, la := range b.add {
if l.Name == la.Name {
continue Outer
}
}
res = append(res, l)
}
res = append(res, b.add...)
sort.Sort(res)
return res
} | |
c167363 | flushDeadline,
samplesIn: newEWMARate(ewmaWeight, shardUpdateDuration),
walDir: walDir,
}
go s.run()
return s
} | |
c167364 |
}
s.queues = newQueues
for _, q := range s.queues {
q.Start()
}
// Update read clients
queryables := make([]storage.Queryable, 0, len(conf.RemoteReadConfigs))
for i, rrConf := range conf.RemoteReadConfigs {
c, err := NewClient(i, &ClientConfig{
URL: rrConf.URL,
Timeout: rrConf.... | |
c167365 |
if err != nil {
return nil, err
}
queriers = append(queriers, q)
}
return storage.NewMergeQuerier(nil, queriers), nil
} | |
c167366 | s.mtx.Unlock()
for _, q := range s.queues {
q.Stop()
}
return nil
} | |
c167367 | limiter: rate.NewLimiter(limit, int(limit)),
next: next,
}
} | |
c167368 | region string, l log.Logger) *HypervisorDiscovery {
return &HypervisorDiscovery{provider: provider, authOpts: opts,
region: region, port: port, logger: l}
} | |
c167369 | *API {
return &API{
db: db,
enableAdmin: enableAdmin,
}
} | |
c167370 | else {
pb.RegisterAdminServer(srv, &AdminDisabled{})
}
} | |
c167371 | context.Context, addr string) (net.Conn, error) {
return (&net.Dialer{}).DialContext(ctx, "tcp", addr)
}),
}
err := pb.RegisterAdminHandlerFromEndpoint(ctx, mux, grpcAddr, opts)
if err != nil {
return nil, err
}
return mux, nil
} | |
c167372 |
if max == nil {
maxt = maxTime
} else {
maxt = *max
}
if mint.After(maxt) {
return mint, maxt, errors.Errorf("min time must be before or equal to max time")
}
return mint, maxt, nil
} | |
c167373 |
return c.writer.Write(p)
} | |
c167374 | {
gzipWriter.Flush()
}
if closer, ok := c.writer.(io.Closer); ok {
defer closer.Close()
}
} | |
c167375 | writer.Header().Set(contentEncodingHeader, deflateEncoding)
return &compressedResponseWriter{
ResponseWriter: writer,
writer: zlib.NewWriter(writer),
}
}
}
return &compressedResponseWriter{
ResponseWriter: writer,
writer: writer,
}
} | |
c167376 | Value float64
}{
Labels: labels,
ExternalLabels: externalLabels,
Value: value,
}
} | |
c167377 | v := range fm {
te.funcMap[k] = v
}
} | |
c167378 | if err != nil {
return "", errors.Wrapf(err, "error parsing template %v", te.name)
}
if len(templateFiles) > 0 {
_, err = tmpl.ParseFiles(templateFiles...)
if err != nil {
return "", errors.Wrapf(err, "error parsing template files for %v", te.name)
}
}
var buffer bytes.Buffer
err = tmpl.Execute(&buffer... | |
c167379 | labels: labels,
discoveredLabels: discoveredLabels,
params: params,
health: HealthUnknown,
}
} | |
c167380 | return MetricMetadata{}, false
}
return t.metadata.getMetadata(metric)
} | |
c167381 | h.Write([]byte(t.URL().String()))
return h.Sum64()
} | |
c167382 | = (t.hash() ^ jitterSeed) % uint64(interval)
next = base + int64(offset)
)
if next > int64(interval) {
next -= int64(interval)
}
return time.Duration(next)
} | |
c167383 | !strings.HasPrefix(l.Name, model.ReservedLabelPrefix) {
lset = append(lset, l)
}
}
return lset
} | |
c167384 | len(t.discoveredLabels))
copy(lset, t.discoveredLabels)
return lset
} | |
c167385 | defer t.mtx.Unlock()
t.discoveredLabels = l
} | |
c167386 | }
}
return &url.URL{
Scheme: t.labels.Get(model.SchemeLabel),
Host: t.labels.Get(model.AddressLabel),
Path: t.labels.Get(model.MetricsPathLabel),
RawQuery: params.Encode(),
}
} | |
c167387 | t.mtx.RUnlock()
return t.lastError
} | |
c167388 | t.mtx.RUnlock()
return t.lastScrape
} | |
c167389 | defer t.mtx.RUnlock()
return t.lastScrapeDuration
} | |
c167390 | t.mtx.RUnlock()
return t.health
} | |
c167391 | }
}
lset := labels.New(lbls...)
lbls, origLabels, err := populateLabels(lset, cfg)
if err != nil {
return nil, errors.Wrapf(err, "instance %d in group %s", i, tg)
}
if lbls != nil || origLabels != nil {
targets = append(targets, NewTarget(lbls, origLabels, cfg.Params))
}
}
return targets, nil
... | |
c167392 | int64(t.Nanosecond())/int64(time.Millisecond)
} | |
c167393 | time.Unix(ts/1000, (ts%1000)*int64(time.Millisecond))
} | |
c167394 | {
w.Header().Set(k, v)
}
if o.String() == "^(?:.*)$" {
w.Header().Set("Access-Control-Allow-Origin", "*")
return
}
if o.MatchString(origin) {
w.Header().Set("Access-Control-Allow-Origin", origin)
}
} | |
c167395 | are
// recoverable.
return recoverableError{err}
}
defer func() {
io.Copy(ioutil.Discard, httpResp.Body)
httpResp.Body.Close()
}()
if httpResp.StatusCode/100 != 2 {
scanner := bufio.NewScanner(io.LimitReader(httpResp.Body, maxErrMsgLen))
line := ""
if scanner.Scan() {
line = scanner.Text()
}
... | |
c167396 | fmt.Sprintf("%d:%s", c.index, c.url)
} | |
c167397 | = ioutil.ReadAll(httpResp.Body)
if err != nil {
return nil, errors.Wrap(err, "error reading response")
}
uncompressed, err := snappy.Decode(nil, compressed)
if err != nil {
return nil, errors.Wrap(err, "error reading response")
}
var resp prompb.ReadResponse
err = proto.Unmarshal(uncompressed, &resp)
if ... | |
c167398 | }
d.Discovery = refresh.NewDiscovery(
logger,
"azure",
time.Duration(cfg.RefreshInterval),
d.refresh,
)
return d
} | |
c167399 | err := adal.NewOAuthConfig(activeDirectoryEndpoint, cfg.TenantID)
if err != nil {
return azureClient{}, err
}
spt, err = adal.NewServicePrincipalToken(*oauthConfig, cfg.ClientID, string(cfg.ClientSecret), resourceManagerEndpoint)
if err != nil {
return azureClient{}, err
}
}
bearerAuthorizer := aut... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.