_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q13400 | ImportMetric | train | func (w *Worker) ImportMetric(other samplers.JSONMetric) {
w.mutex.Lock()
defer w.mutex.Unlock()
// we don't increment the processed metric counter here, it was already
// counted by the original veneur that sent this to us
w.imported++
if other.Type == counterTypeName || other.Type == gaugeTypeName {
// this ... | go | {
"resource": ""
} |
q13401 | ImportMetricGRPC | train | func (w *Worker) ImportMetricGRPC(other *metricpb.Metric) (err error) {
w.mutex.Lock()
defer w.mutex.Unlock()
key := samplers.NewMetricKeyFromMetric(other)
scope := samplers.ScopeFromPB(other.Scope)
if other.Type == metricpb.Type_Counter || other.Type == metricpb.Type_Gauge {
scope = samplers.GlobalOnly
}
i... | go | {
"resource": ""
} |
q13402 | Flush | train | func (w *Worker) Flush() WorkerMetrics {
// This is a critical spot. The worker can't process metrics while this
// mutex is held! So we try and minimize it by copying the maps of values
// and assigning new ones.
wm := NewWorkerMetrics()
w.mutex.Lock()
ret := w.wm
processed := w.processed
imported := w.importe... | go | {
"resource": ""
} |
q13403 | NewEventWorker | train | func NewEventWorker(cl *trace.Client, stats *statsd.Client) *EventWorker {
return &EventWorker{
sampleChan: make(chan ssf.SSFSample),
mutex: &sync.Mutex{},
traceClient: cl,
stats: stats,
}
} | go | {
"resource": ""
} |
q13404 | Work | train | func (ew *EventWorker) Work() {
for {
select {
case s := <-ew.sampleChan:
ew.mutex.Lock()
ew.samples = append(ew.samples, s)
ew.mutex.Unlock()
}
}
} | go | {
"resource": ""
} |
q13405 | Flush | train | func (ew *EventWorker) Flush() []ssf.SSFSample {
ew.mutex.Lock()
retsamples := ew.samples
// these slices will be allocated again at append time
ew.samples = nil
ew.mutex.Unlock()
if len(retsamples) != 0 {
ew.stats.Count("worker.other_samples_flushed_total", int64(len(retsamples)), nil, 1.0)
}
return retsam... | go | {
"resource": ""
} |
q13406 | NewSpanWorker | train | func NewSpanWorker(sinks []sinks.SpanSink, cl *trace.Client, statsd *statsd.Client, spanChan <-chan *ssf.SSFSpan, commonTags map[string]string) *SpanWorker {
tags := make([]map[string]string, len(sinks))
for i, sink := range sinks {
tags[i] = map[string]string{
"sink": sink.Name(),
}
}
return &SpanWorker{
... | go | {
"resource": ""
} |
q13407 | Flush | train | func (tw *SpanWorker) Flush() {
samples := &ssf.Samples{}
// Flush and time each sink.
for i, s := range tw.sinks {
tags := make([]string, 0, len(tw.sinkTags[i]))
for k, v := range tw.sinkTags[i] {
tags = append(tags, fmt.Sprintf("%s:%s", k, v))
}
sinkFlushStart := time.Now()
s.Flush()
tw.statsd.Timi... | go | {
"resource": ""
} |
q13408 | ReadProxyConfig | train | func ReadProxyConfig(path string) (c ProxyConfig, err error) {
f, err := os.Open(path)
if err != nil {
return c, err
}
defer f.Close()
c, err = readProxyConfig(f)
c.applyDefaults()
return
} | go | {
"resource": ""
} |
q13409 | ParseInterval | train | func (c Config) ParseInterval() (time.Duration, error) {
return time.ParseDuration(c.Interval)
} | go | {
"resource": ""
} |
q13410 | RefreshDestinations | train | func (p *Proxy) RefreshDestinations(serviceName string, ring *consistent.Consistent, mtx *sync.Mutex) {
samples := &ssf.Samples{}
defer metrics.Report(p.TraceClient, samples)
srvTags := map[string]string{"service": serviceName}
start := time.Now()
destinations, err := p.Discoverer.GetDestinationsForService(servic... | go | {
"resource": ""
} |
q13411 | ProxyMetrics | train | func (p *Proxy) ProxyMetrics(ctx context.Context, jsonMetrics []samplers.JSONMetric, origin string) {
span, _ := trace.StartSpanFromContext(ctx, "veneur.opentracing.proxy.proxy_metrics")
defer span.ClientFinish(p.TraceClient)
if p.ForwardTimeout > 0 {
var cancel func()
ctx, cancel = context.WithTimeout(ctx, p.F... | go | {
"resource": ""
} |
q13412 | ImportMetrics | train | func (s *Server) ImportMetrics(ctx context.Context, jsonMetrics []samplers.JSONMetric) {
span, _ := trace.StartSpanFromContext(ctx, "veneur.opentracing.import.import_metrics")
defer span.Finish()
// we have a slice of json metrics that we need to divide up across the workers
// we don't want to push one metric at ... | go | {
"resource": ""
} |
q13413 | newJSONMetricsByWorker | train | func newJSONMetricsByWorker(metrics []samplers.JSONMetric, numWorkers int) *jsonMetricsByWorker {
ret := &jsonMetricsByWorker{
sjm: newSortableJSONMetrics(metrics, numWorkers),
}
sort.Sort(ret.sjm)
return ret
} | go | {
"resource": ""
} |
q13414 | submitter | train | func (sss *splunkSpanSink) submitter(sync chan struct{}, ready chan struct{}) {
ctx := context.Background()
for {
exit := sss.submitBatch(ctx, sync, ready)
if exit {
return
}
}
} | go | {
"resource": ""
} |
q13415 | setupHTTPRequest | train | func (sss *splunkSpanSink) setupHTTPRequest(ctx context.Context) (context.CancelFunc, *hecRequest, io.Writer, error) {
ctx, cancel := context.WithCancel(ctx)
hecReq := sss.hec.newRequest()
req, w, err := hecReq.Start(ctx)
if err != nil {
cancel()
return nil, nil, nil, err
}
// At this point, we have a workab... | go | {
"resource": ""
} |
q13416 | submitOneEvent | train | func (sss *splunkSpanSink) submitOneEvent(ctx context.Context, w io.Writer, ev *Event) error {
if sss.sendTimeout > 0 {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, sss.sendTimeout)
defer cancel()
}
encodeErrors := make(chan error)
enc := json.NewEncoder(w)
go func() {
err := enc.En... | go | {
"resource": ""
} |
q13417 | Flush | train | func (sss *splunkSpanSink) Flush() {
// report the sink stats:
samples := &ssf.Samples{}
samples.Add(
ssf.Count(
sinks.MetricKeyTotalSpansFlushed,
float32(atomic.SwapUint32(&sss.ingestedSpans, 0)),
map[string]string{"sink": sss.Name()}),
ssf.Count(
sinks.MetricKeyTotalSpansDropped,
float32(atomic.... | go | {
"resource": ""
} |
q13418 | NewLightStepSpanSink | train | func NewLightStepSpanSink(collector string, reconnectPeriod string, maximumSpans int, numClients int, accessToken string, log *logrus.Logger) (*LightStepSpanSink, error) {
var host *url.URL
host, err := url.Parse(collector)
if err != nil {
log.WithError(err).WithField(
"host", collector,
).Error("Error parsin... | go | {
"resource": ""
} |
q13419 | Ingest | train | func (ls *LightStepSpanSink) Ingest(ssfSpan *ssf.SSFSpan) error {
if err := protocol.ValidateTrace(ssfSpan); err != nil {
return err
}
parentID := ssfSpan.ParentId
if parentID <= 0 {
parentID = 0
}
var errorCode int64
if ssfSpan.Error {
errorCode = 1
}
timestamp := time.Unix(ssfSpan.StartTimestamp/1e9... | go | {
"resource": ""
} |
q13420 | Flush | train | func (ls *LightStepSpanSink) Flush() {
ls.mutex.Lock()
defer ls.mutex.Unlock()
samples := &ssf.Samples{}
defer metrics.Report(ls.traceClient, samples)
totalCount := int64(0)
ls.serviceCount.Range(func(keyI, valueI interface{}) bool {
service, ok := keyI.(string)
if !ok {
ls.log.WithFields(logrus.Fields{... | go | {
"resource": ""
} |
q13421 | NewConsul | train | func NewConsul(config *api.Config) (*Consul, error) {
consulClient, err := api.NewClient(config)
if err != nil {
return nil, err
}
return &Consul{
ConsulHealth: consulClient.Health(),
}, nil
} | go | {
"resource": ""
} |
q13422 | sendMetrics | train | func (m *metricExtractionSink) sendMetrics(metrics []samplers.UDPMetric) {
for _, metric := range metrics {
m.workers[metric.Digest%uint32(len(m.workers))].IngestUDP(metric)
}
} | go | {
"resource": ""
} |
q13423 | Ingest | train | func (m *metricExtractionSink) Ingest(span *ssf.SSFSpan) error {
var metricsCount int
defer func() {
atomic.AddInt64(&m.metricsGenerated, int64(metricsCount))
atomic.AddInt64(&m.spansProcessed, 1)
}()
metrics, err := samplers.ConvertMetrics(span)
if err != nil {
if _, ok := err.(samplers.InvalidMetrics); ok ... | go | {
"resource": ""
} |
q13424 | NewSocket | train | func NewSocket(addr *net.UDPAddr, recvBuf int, reuseport bool) (net.PacketConn, error) {
if reuseport {
panic("SO_REUSEPORT not supported on this platform")
}
serverConn, err := net.ListenUDP("udp", addr)
if err != nil {
return nil, err
}
if err := serverConn.SetReadBuffer(recvBuf); err != nil {
return nil,... | go | {
"resource": ""
} |
q13425 | Flush | train | func (p *Plugin) Flush(ctx context.Context, metrics []samplers.InterMetric) error {
f, err := os.OpenFile(p.FilePath, os.O_RDWR|os.O_APPEND|os.O_CREATE, os.ModePerm)
defer f.Close()
if err != nil {
return fmt.Errorf("couldn't open %s for appending: %s", p.FilePath, err)
}
appendToWriter(f, metrics, p.hostname, ... | go | {
"resource": ""
} |
q13426 | IsFramingError | train | func IsFramingError(err error) bool {
switch err.(type) {
case *errFrameVersion:
return true
case *errFramingIO:
return true
case *errFrameLength:
return true
}
return false
} | go | {
"resource": ""
} |
q13427 | Add | train | func (s *Samples) Add(sample ...*SSFSample) {
if s.Batch == nil {
s.Batch = []*SSFSample{}
}
s.Batch = append(s.Batch, sample...)
} | go | {
"resource": ""
} |
q13428 | Timestamp | train | func Timestamp(ts time.Time) SampleOption {
return func(s *SSFSample) {
s.Timestamp = ts.UnixNano()
}
} | go | {
"resource": ""
} |
q13429 | TimeUnit | train | func TimeUnit(resolution time.Duration) SampleOption {
return func(s *SSFSample) {
if unit, ok := resolutions[resolution]; ok {
s.Unit = unit
}
}
} | go | {
"resource": ""
} |
q13430 | Gauge | train | func Gauge(name string, value float32, tags map[string]string, opts ...SampleOption) *SSFSample {
return create(&SSFSample{
Metric: SSFSample_GAUGE,
Name: name,
Value: value,
Tags: tags,
SampleRate: 1.0,
}, opts)
} | go | {
"resource": ""
} |
q13431 | Histogram | train | func Histogram(name string, value float32, tags map[string]string, opts ...SampleOption) *SSFSample {
return create(&SSFSample{
Metric: SSFSample_HISTOGRAM,
Name: name,
Value: value,
Tags: tags,
SampleRate: 1.0,
}, opts)
} | go | {
"resource": ""
} |
q13432 | Set | train | func Set(name string, value string, tags map[string]string, opts ...SampleOption) *SSFSample {
return create(&SSFSample{
Metric: SSFSample_SET,
Name: name,
Message: value,
Tags: tags,
SampleRate: 1.0,
}, opts)
} | go | {
"resource": ""
} |
q13433 | Status | train | func Status(name string, state SSFSample_Status, tags map[string]string, opts ...SampleOption) *SSFSample {
return create(&SSFSample{
Metric: SSFSample_STATUS,
Name: name,
Status: state,
Tags: tags,
SampleRate: 1.0,
}, opts)
} | go | {
"resource": ""
} |
q13434 | IsAcceptableMetric | train | func IsAcceptableMetric(metric samplers.InterMetric, sink MetricSink) bool {
if metric.Sinks == nil {
return true
}
return metric.Sinks.RouteTo(sink.Name())
} | go | {
"resource": ""
} |
q13435 | runOnce | train | func runOnce(distribution func() float64, compression float64, samples int, distname string, run int, deviations, centroidErrors, errors, sizes *csv.Writer) {
td := tdigest.NewMerging(compression, true)
allSamples := make([]float64, samples)
for i := 0; i < samples; i++ {
sample := distribution()
td.Add(sample,... | go | {
"resource": ""
} |
q13436 | Get | train | func (m *clientConnMap) Get(dest string) (conn *grpc.ClientConn, ok bool) {
m.RLock()
conn, ok = m.conns[dest]
m.RUnlock()
return
} | go | {
"resource": ""
} |
q13437 | Add | train | func (m *clientConnMap) Add(dest string) error {
// If the connection already exists, just exit early
if _, ok := m.Get(dest); ok {
return nil
}
conn, err := grpc.Dial(dest, m.options...)
m.Lock()
_, ok := m.conns[dest]
if !ok && err == nil {
m.conns[dest] = conn
}
m.Unlock()
if ok && err == nil {
_ ... | go | {
"resource": ""
} |
q13438 | Delete | train | func (m *clientConnMap) Delete(dest string) {
m.Lock()
if conn, ok := m.conns[dest]; ok {
_ = conn.Close()
}
delete(m.conns, dest)
m.Unlock()
} | go | {
"resource": ""
} |
q13439 | Keys | train | func (m *clientConnMap) Keys() []string {
m.RLock()
res := make([]string, 0, len(m.conns))
for k := range m.conns {
res = append(res, k)
}
m.RUnlock()
return res
} | go | {
"resource": ""
} |
q13440 | Clear | train | func (m *clientConnMap) Clear() {
m.Lock()
for _, conn := range m.conns {
_ = conn.Close()
}
m.conns = make(map[string]*grpc.ClientConn)
m.Unlock()
} | go | {
"resource": ""
} |
q13441 | NewClient | train | func NewClient(endpoint, apiKey string, client *http.Client) DPClient {
baseURL, err := url.Parse(endpoint)
if err != nil {
panic(fmt.Sprintf("Could not parse endpoint base URL %q: %v", endpoint, err))
}
httpSink := sfxclient.NewHTTPSink()
httpSink.AuthToken = apiKey
httpSink.DatapointEndpoint = baseURL.Resolve... | go | {
"resource": ""
} |
q13442 | NewSignalFxSink | train | func NewSignalFxSink(hostnameTag string, hostname string, commonDimensions map[string]string, log *logrus.Logger, client DPClient, varyBy string, perTagClients map[string]DPClient, metricNamePrefixDrops []string, metricTagPrefixDrops []string, derivedMetrics samplers.DerivedMetricsProcessor, maxPointsInBatch int) (*Sig... | go | {
"resource": ""
} |
q13443 | Start | train | func (sfx *SignalFxSink) Start(traceClient *trace.Client) error {
sfx.traceClient = traceClient
return nil
} | go | {
"resource": ""
} |
q13444 | client | train | func (sfx *SignalFxSink) client(key string) DPClient {
if cl, ok := sfx.clientsByTagValue[key]; ok {
return cl
}
return sfx.defaultClient
} | go | {
"resource": ""
} |
q13445 | newPointCollection | train | func (sfx *SignalFxSink) newPointCollection() *collection {
return &collection{
sink: sfx,
points: []*datapoint.Datapoint{},
pointsByKey: map[string][]*datapoint.Datapoint{},
}
} | go | {
"resource": ""
} |
q13446 | FlushOtherSamples | train | func (sfx *SignalFxSink) FlushOtherSamples(ctx context.Context, samples []ssf.SSFSample) {
span, _ := trace.StartSpanFromContext(ctx, "")
defer span.ClientFinish(sfx.traceClient)
var countFailed = 0
var countSuccess = 0
for _, sample := range samples {
if _, ok := sample.Tags[dogstatsd.EventIdentifierKey]; ok {
... | go | {
"resource": ""
} |
q13447 | HandleTracePacket | train | func (s *Server) HandleTracePacket(packet []byte) {
samples := &ssf.Samples{}
defer metrics.Report(s.TraceClient, samples)
// Unlike metrics, protobuf shouldn't have an issue with 0-length packets
if len(packet) == 0 {
s.Statsd.Count("ssf.error_total", 1, []string{"ssf_format:packet", "packet_type:unknown", "rea... | go | {
"resource": ""
} |
q13448 | ReadMetricSocket | train | func (s *Server) ReadMetricSocket(serverConn net.PacketConn, packetPool *sync.Pool) {
for {
buf := packetPool.Get().([]byte)
n, _, err := serverConn.ReadFrom(buf)
if err != nil {
log.WithError(err).Error("Error reading from UDP metrics socket")
continue
}
s.processMetricPacket(n, buf, packetPool)
}
} | go | {
"resource": ""
} |
q13449 | processMetricPacket | train | func (s *Server) processMetricPacket(numBytes int, buf []byte, packetPool *sync.Pool) {
if numBytes > s.metricMaxLength {
metrics.ReportOne(s.TraceClient, ssf.Count("packet.error_total", 1, map[string]string{"packet_type": "unknown", "reason": "toolong"}))
return
}
// statsd allows multiple packets to be joined... | go | {
"resource": ""
} |
q13450 | ReadStatsdDatagramSocket | train | func (s *Server) ReadStatsdDatagramSocket(serverConn *net.UnixConn, packetPool *sync.Pool) {
for {
buf := packetPool.Get().([]byte)
n, _, err := serverConn.ReadFromUnix(buf)
if err != nil {
select {
case <-s.shutdown:
log.WithError(err).Info("Ignoring ReadFrom error while shutting down")
return
... | go | {
"resource": ""
} |
q13451 | ReadSSFPacketSocket | train | func (s *Server) ReadSSFPacketSocket(serverConn net.PacketConn, packetPool *sync.Pool) {
// TODO This is duplicated from ReadMetricSocket and feels like it could be it's
// own function?
p := packetPool.Get().([]byte)
if len(p) == 0 {
log.WithField("len", len(p)).Fatal(
"packetPool making empty slices: trace_m... | go | {
"resource": ""
} |
q13452 | ReadTCPSocket | train | func (s *Server) ReadTCPSocket(listener net.Listener) {
for {
conn, err := listener.Accept()
if err != nil {
select {
case <-s.shutdown:
// occurs when cleanly shutting down the server e.g. in tests; ignore errors
log.WithError(err).Info("Ignoring Accept error while shutting down")
return
defa... | go | {
"resource": ""
} |
q13453 | HTTPServe | train | func (s *Server) HTTPServe() {
var prf interface {
Stop()
}
// We want to make sure the profile is stopped
// exactly once (and only once), even if the
// shutdown pre-hook does not run (which it may not)
profileStopOnce := sync.Once{}
if s.enableProfiling {
profileStartOnce.Do(func() {
prf = profile.St... | go | {
"resource": ""
} |
q13454 | registerPlugin | train | func (s *Server) registerPlugin(p plugins.Plugin) {
s.pluginMtx.Lock()
defer s.pluginMtx.Unlock()
s.plugins = append(s.plugins, p)
} | go | {
"resource": ""
} |
q13455 | CalculateTickDelay | train | func CalculateTickDelay(interval time.Duration, t time.Time) time.Duration {
return t.Truncate(interval).Add(interval).Sub(t)
} | go | {
"resource": ""
} |
q13456 | setSinkExcludedTags | train | func setSinkExcludedTags(excludeRules []string, metricSinks []sinks.MetricSink) {
type excludableSink interface {
SetExcludedTags([]string)
}
for _, sink := range metricSinks {
if s, ok := sink.(excludableSink); ok {
excludedTags := generateExcludedTags(excludeRules, sink.Name())
log.WithFields(logrus.Fie... | go | {
"resource": ""
} |
q13457 | ValidTrace | train | func ValidTrace(span *ssf.SSFSpan) bool {
return span.Id != 0 &&
span.TraceId != 0 &&
span.StartTimestamp != 0 &&
span.EndTimestamp != 0 &&
span.Name != ""
} | go | {
"resource": ""
} |
q13458 | ValidateTrace | train | func ValidateTrace(span *ssf.SSFSpan) error {
if !ValidTrace(span) {
return &InvalidTrace{span}
}
return nil
} | go | {
"resource": ""
} |
q13459 | WriteSSF | train | func WriteSSF(out io.Writer, ssf *ssf.SSFSpan) (int, error) {
pbuf := pbufPool.Get().(*proto.Buffer)
err := pbuf.Marshal(ssf)
if err != nil {
// This is not a framing error, as we haven't written
// anything to the stream yet.
return 0, err
}
defer func() {
// Make sure we reset the scratch protobuffer (by... | go | {
"resource": ""
} |
q13460 | NewDatadogMetricSink | train | func NewDatadogMetricSink(interval float64, flushMaxPerBody int, hostname string, tags []string, ddHostname string, apiKey string, httpClient *http.Client, log *logrus.Logger) (*DatadogMetricSink, error) {
return &DatadogMetricSink{
HTTPClient: httpClient,
APIKey: apiKey,
DDHostname: ddHostnam... | go | {
"resource": ""
} |
q13461 | Flush | train | func (dd *DatadogMetricSink) Flush(ctx context.Context, interMetrics []samplers.InterMetric) error {
span, _ := trace.StartSpanFromContext(ctx, "")
defer span.ClientFinish(dd.traceClient)
ddmetrics, checks := dd.finalizeMetrics(interMetrics)
if len(checks) != 0 {
// this endpoint is not documented to take an ar... | go | {
"resource": ""
} |
q13462 | NewDatadogSpanSink | train | func NewDatadogSpanSink(address string, bufferSize int, httpClient *http.Client, log *logrus.Logger) (*DatadogSpanSink, error) {
if bufferSize == 0 {
bufferSize = datadogSpanBufferSize
}
return &DatadogSpanSink{
HTTPClient: httpClient,
bufferSize: bufferSize,
buffer: ring.New(bufferSize),
mutex:... | go | {
"resource": ""
} |
q13463 | Ingest | train | func (dd *DatadogSpanSink) Ingest(span *ssf.SSFSpan) error {
if err := protocol.ValidateTrace(span); err != nil {
return err
}
dd.mutex.Lock()
defer dd.mutex.Unlock()
dd.buffer.Value = span
dd.buffer = dd.buffer.Next()
return nil
} | go | {
"resource": ""
} |
q13464 | Capacity | train | func Capacity(n uint) ClientParam {
return func(cl *Client) error {
cl.cap = n
return nil
}
} | go | {
"resource": ""
} |
q13465 | BufferedSize | train | func BufferedSize(size uint) ClientParam {
return func(cl *Client) error {
if cl.backendParams != nil {
cl.backendParams.bufferSize = size
return nil
}
return ErrClientNotNetworked
}
} | go | {
"resource": ""
} |
q13466 | FlushInterval | train | func FlushInterval(interval time.Duration) ClientParam {
t := time.NewTicker(interval)
return FlushChannel(t.C, t.Stop)
} | go | {
"resource": ""
} |
q13467 | FlushChannel | train | func FlushChannel(ch <-chan time.Time, stop func()) ClientParam {
return func(cl *Client) error {
if cl.backendParams == nil {
return ErrClientNotNetworked
}
cl.flush = func(ctx context.Context) {
defer stop()
for {
select {
case <-ch:
_ = Flush(cl)
case <-ctx.Done():
return
}
... | go | {
"resource": ""
} |
q13468 | MaxBackoffTime | train | func MaxBackoffTime(t time.Duration) ClientParam {
return func(cl *Client) error {
if cl.backendParams != nil {
cl.backendParams.maxBackoff = t
return nil
}
return ErrClientNotNetworked
}
} | go | {
"resource": ""
} |
q13469 | ParallelBackends | train | func ParallelBackends(nBackends uint) ClientParam {
return func(cl *Client) error {
if cl.backendParams == nil {
return ErrClientNotNetworked
}
cl.nBackends = nBackends
return nil
}
} | go | {
"resource": ""
} |
q13470 | NewChannelClient | train | func NewChannelClient(spanChan chan<- *ssf.SSFSpan, opts ...ClientParam) (*Client, error) {
cl := &Client{}
cl.flushBackends = []flushNotifier{}
cl.spans = spanChan
for _, opt := range opts {
if err := opt(cl); err != nil {
return nil, err
}
}
ctx := context.Background()
ctx, cl.cancel = context.WithCan... | go | {
"resource": ""
} |
q13471 | SetDefaultClient | train | func SetDefaultClient(client *Client) {
oldClient := DefaultClient
DefaultClient = client
// Ensure the old client is closed so it does not leak connections
if oldClient != nil {
oldClient.Close()
}
} | go | {
"resource": ""
} |
q13472 | NeutralizeClient | train | func NeutralizeClient(client *Client) {
client.Close()
client.records = nil
client.spans = nil
client.flushBackends = []flushNotifier{}
} | go | {
"resource": ""
} |
q13473 | Record | train | func Record(cl *Client, span *ssf.SSFSpan, done chan<- error) error {
if cl == nil {
return ErrNoClient
}
op := &recordOp{span: span, result: done}
select {
case cl.spans <- span:
atomic.AddInt64(&cl.successfulRecords, 1)
if done != nil {
go func() { done <- nil }()
}
return nil
case cl.records <- o... | go | {
"resource": ""
} |
q13474 | NewMerging | train | func NewMerging(compression float64, debug bool) *MergingDigest {
// this is a provable upper bound on the size of the centroid list
// TODO: derive it myself
sizeBound := int((math.Pi * compression / 2) + 0.5)
return &MergingDigest{
compression: compression,
mainCentroids: make([]Centroid, 0, sizeBound),
... | go | {
"resource": ""
} |
q13475 | NewMergingFromData | train | func NewMergingFromData(d *MergingDigestData) *MergingDigest {
td := &MergingDigest{
compression: d.Compression,
mainCentroids: d.MainCentroids,
tempCentroids: make([]Centroid, 0, estimateTempBuffer(d.Compression)),
min: d.Min,
max: d.Max,
reciprocalSum: d.ReciprocalSum,
}
// Initi... | go | {
"resource": ""
} |
q13476 | Add | train | func (td *MergingDigest) Add(value float64, weight float64) {
if math.IsNaN(value) || math.IsInf(value, 0) || weight <= 0 {
panic("invalid value added")
}
if len(td.tempCentroids) == cap(td.tempCentroids) {
td.mergeAllTemps()
}
td.min = math.Min(td.min, value)
td.max = math.Max(td.max, value)
td.reciprocal... | go | {
"resource": ""
} |
q13477 | mergeAllTemps | train | func (td *MergingDigest) mergeAllTemps() {
// this optimization is really important! if you remove it, the main list
// will get merged into itself every time this is called
if len(td.tempCentroids) == 0 {
return
}
// we iterate over both centroid lists from least to greatest mean, so first
// we have to sort ... | go | {
"resource": ""
} |
q13478 | indexEstimate | train | func (td *MergingDigest) indexEstimate(quantile float64) float64 {
// TODO: a polynomial approximation of arcsine should be a lot faster
return td.compression * ((math.Asin(2*quantile-1) / math.Pi) + 0.5)
} | go | {
"resource": ""
} |
q13479 | Quantile | train | func (td *MergingDigest) Quantile(quantile float64) float64 {
if quantile < 0 || quantile > 1 {
panic("quantile out of bounds")
}
td.mergeAllTemps()
// add up the weights of centroids in ascending order until we reach a
// centroid that pushes us over the quantile
q := quantile * td.mainWeight
weightSoFar := ... | go | {
"resource": ""
} |
q13480 | Merge | train | func (td *MergingDigest) Merge(other *MergingDigest) {
oldReciprocalSum := td.reciprocalSum
shuffledIndices := rand.Perm(len(other.mainCentroids))
for _, i := range shuffledIndices {
td.Add(other.mainCentroids[i].Mean, other.mainCentroids[i].Weight)
}
// we did not merge other's temps, so we need to add those ... | go | {
"resource": ""
} |
q13481 | Centroids | train | func (td *MergingDigest) Centroids() []Centroid {
if !td.debug {
panic("must enable debug to call Centroids()")
}
td.mergeAllTemps()
return td.mainCentroids
} | go | {
"resource": ""
} |
q13482 | tallyMetrics | train | func (s *Server) tallyMetrics(percentiles []float64) ([]WorkerMetrics, metricsSummary) {
// allocating this long array to count up the sizes is cheaper than appending
// the []WorkerMetrics together one at a time
tempMetrics := make([]WorkerMetrics, 0, len(s.Workers))
ms := metricsSummary{}
for i, w := range s.W... | go | {
"resource": ""
} |
q13483 | forwardGRPC | train | func (s *Server) forwardGRPC(ctx context.Context, wms []WorkerMetrics) {
span, _ := trace.StartSpanFromContext(ctx, "")
span.SetTag("protocol", "grpc")
defer span.ClientFinish(s.TraceClient)
exportStart := time.Now()
// Collect all of the forwardable metrics from the various WorkerMetrics.
var metrics []*metric... | go | {
"resource": ""
} |
q13484 | EvaluateAsNodeset | train | func (xpath *XPath) EvaluateAsNodeset(nodePtr unsafe.Pointer, xpathExpr *Expression) (nodes []unsafe.Pointer, err error) {
if nodePtr == nil {
//evaluating xpath on a nil node returns no result.
return
}
err = xpath.Evaluate(nodePtr, xpathExpr)
if err != nil {
return
}
nodes, err = xpath.ResultAsNodeset(... | go | {
"resource": ""
} |
q13485 | ResultAsNodeset | train | func (xpath *XPath) ResultAsNodeset() (nodes []unsafe.Pointer, err error) {
if xpath.ResultPtr == nil {
return
}
if xpath.ReturnType() != XPATH_NODESET {
err = errors.New("Cannot convert XPath result to nodeset")
}
if nodesetPtr := xpath.ResultPtr.nodesetval; nodesetPtr != nil {
if nodesetSize := int(nodes... | go | {
"resource": ""
} |
q13486 | ResultAsString | train | func (xpath *XPath) ResultAsString() (val string, err error) {
if xpath.ReturnType() != XPATH_STRING {
xpath.ResultPtr = C.xmlXPathConvertString(xpath.ResultPtr)
}
val = C.GoString((*C.char)(unsafe.Pointer(xpath.ResultPtr.stringval)))
return
} | go | {
"resource": ""
} |
q13487 | ResultAsNumber | train | func (xpath *XPath) ResultAsNumber() (val float64, err error) {
if xpath.ReturnType() != XPATH_NUMBER {
xpath.ResultPtr = C.xmlXPathConvertNumber(xpath.ResultPtr)
}
val = float64(xpath.ResultPtr.floatval)
return
} | go | {
"resource": ""
} |
q13488 | ResultAsBoolean | train | func (xpath *XPath) ResultAsBoolean() (val bool, err error) {
xpath.ResultPtr = C.xmlXPathConvertBoolean(xpath.ResultPtr)
val = xpath.ResultPtr.boolval != 0
return
} | go | {
"resource": ""
} |
q13489 | SetResolver | train | func (xpath *XPath) SetResolver(v VariableScope) {
C.set_var_lookup(xpath.ContextPtr, unsafe.Pointer(&v))
C.set_function_lookup(xpath.ContextPtr, unsafe.Pointer(&v))
} | go | {
"resource": ""
} |
q13490 | NewNode | train | func NewNode(nodePtr unsafe.Pointer, document Document) (node Node) {
if nodePtr == nil {
return nil
}
xmlNode := &XmlNode{
Ptr: (*C.xmlNode)(nodePtr),
Document: document,
valid: true,
}
nodeType := NodeType(C.getNodeType((*C.xmlNode)(nodePtr)))
switch nodeType {
default:
node = xmlNode
case ... | go | {
"resource": ""
} |
q13491 | AddChild | train | func (xmlNode *XmlNode) AddChild(data interface{}) (err error) {
switch t := data.(type) {
default:
if nodes, err := xmlNode.coerce(data); err == nil {
for _, node := range nodes {
if err = xmlNode.addChild(node); err != nil {
break
}
}
}
case *DocumentFragment:
if nodes, err := xmlNode.coer... | go | {
"resource": ""
} |
q13492 | AddPreviousSibling | train | func (xmlNode *XmlNode) AddPreviousSibling(data interface{}) (err error) {
switch t := data.(type) {
default:
if nodes, err := xmlNode.coerce(data); err == nil {
for _, node := range nodes {
if err = xmlNode.addPreviousSibling(node); err != nil {
break
}
}
}
case *DocumentFragment:
if nodes,... | go | {
"resource": ""
} |
q13493 | AddNextSibling | train | func (xmlNode *XmlNode) AddNextSibling(data interface{}) (err error) {
switch t := data.(type) {
default:
if nodes, err := xmlNode.coerce(data); err == nil {
for i := len(nodes) - 1; i >= 0; i-- {
node := nodes[i]
if err = xmlNode.addNextSibling(node); err != nil {
break
}
}
}
case *Docume... | go | {
"resource": ""
} |
q13494 | NodePtr | train | func (xmlNode *XmlNode) NodePtr() (p unsafe.Pointer) {
p = unsafe.Pointer(xmlNode.Ptr)
return
} | go | {
"resource": ""
} |
q13495 | Path | train | func (xmlNode *XmlNode) Path() (path string) {
pathPtr := C.xmlGetNodePath(xmlNode.Ptr)
if pathPtr != nil {
p := (*C.char)(unsafe.Pointer(pathPtr))
defer C.xmlFreeChars(p)
path = C.GoString(p)
}
return
} | go | {
"resource": ""
} |
q13496 | Attribute | train | func (xmlNode *XmlNode) Attribute(name string) (attribute *AttributeNode) {
if xmlNode.NodeType() != XML_ELEMENT_NODE {
return
}
nameBytes := GetCString([]byte(name))
namePtr := unsafe.Pointer(&nameBytes[0])
attrPtr := C.xmlHasNsProp(xmlNode.Ptr, (*C.xmlChar)(namePtr), nil)
if attrPtr == nil {
return
} else ... | go | {
"resource": ""
} |
q13497 | Attr | train | func (xmlNode *XmlNode) Attr(name string) (val string) {
if xmlNode.NodeType() != XML_ELEMENT_NODE {
return
}
nameBytes := GetCString([]byte(name))
namePtr := unsafe.Pointer(&nameBytes[0])
valPtr := C.xmlGetProp(xmlNode.Ptr, (*C.xmlChar)(namePtr))
if valPtr == nil {
return
}
p := unsafe.Pointer(valPtr)
def... | go | {
"resource": ""
} |
q13498 | Search | train | func (xmlNode *XmlNode) Search(data interface{}) (result []Node, err error) {
switch data := data.(type) {
default:
err = ERR_UNDEFINED_SEARCH_PARAM
case string:
if xpathExpr := xpath.Compile(data); xpathExpr != nil {
defer xpathExpr.Free()
result, err = xmlNode.Search(xpathExpr)
} else {
err = errors... | go | {
"resource": ""
} |
q13499 | EvalXPathAsBoolean | train | func (xmlNode *XmlNode) EvalXPathAsBoolean(data interface{}, v xpath.VariableScope) (result bool) {
switch data := data.(type) {
case string:
if xpathExpr := xpath.Compile(data); xpathExpr != nil {
defer xpathExpr.Free()
result = xmlNode.EvalXPathAsBoolean(xpathExpr, v)
} else {
//err = errors.New("canno... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.