repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
jaegertracing/jaeger-client-go | zipkin/propagation.go | Extract | func (p Propagator) Extract(abstractCarrier interface{}) (jaeger.SpanContext, error) {
textMapReader, ok := abstractCarrier.(opentracing.TextMapReader)
if !ok {
return jaeger.SpanContext{}, opentracing.ErrInvalidCarrier
}
var traceID jaeger.TraceID
var spanID uint64
var parentID uint64
sampled := false
var baggage map[string]string
err := textMapReader.ForeachKey(func(rawKey, value string) error {
key := strings.ToLower(rawKey) // TODO not necessary for plain TextMap
var err error
if key == "x-b3-traceid" {
traceID, err = jaeger.TraceIDFromString(value)
} else if key == "x-b3-parentspanid" {
parentID, err = strconv.ParseUint(value, 16, 64)
} else if key == "x-b3-spanid" {
spanID, err = strconv.ParseUint(value, 16, 64)
} else if key == "x-b3-sampled" && (value == "1" || value == "true") {
sampled = true
} else if strings.HasPrefix(key, p.baggagePrefix) {
if baggage == nil {
baggage = make(map[string]string)
}
baggage[key[len(p.baggagePrefix):]] = value
}
return err
})
if err != nil {
return jaeger.SpanContext{}, err
}
if !traceID.IsValid() {
return jaeger.SpanContext{}, opentracing.ErrSpanContextNotFound
}
return jaeger.NewSpanContext(
traceID,
jaeger.SpanID(spanID),
jaeger.SpanID(parentID),
sampled, baggage), nil
} | go | func (p Propagator) Extract(abstractCarrier interface{}) (jaeger.SpanContext, error) {
textMapReader, ok := abstractCarrier.(opentracing.TextMapReader)
if !ok {
return jaeger.SpanContext{}, opentracing.ErrInvalidCarrier
}
var traceID jaeger.TraceID
var spanID uint64
var parentID uint64
sampled := false
var baggage map[string]string
err := textMapReader.ForeachKey(func(rawKey, value string) error {
key := strings.ToLower(rawKey) // TODO not necessary for plain TextMap
var err error
if key == "x-b3-traceid" {
traceID, err = jaeger.TraceIDFromString(value)
} else if key == "x-b3-parentspanid" {
parentID, err = strconv.ParseUint(value, 16, 64)
} else if key == "x-b3-spanid" {
spanID, err = strconv.ParseUint(value, 16, 64)
} else if key == "x-b3-sampled" && (value == "1" || value == "true") {
sampled = true
} else if strings.HasPrefix(key, p.baggagePrefix) {
if baggage == nil {
baggage = make(map[string]string)
}
baggage[key[len(p.baggagePrefix):]] = value
}
return err
})
if err != nil {
return jaeger.SpanContext{}, err
}
if !traceID.IsValid() {
return jaeger.SpanContext{}, opentracing.ErrSpanContextNotFound
}
return jaeger.NewSpanContext(
traceID,
jaeger.SpanID(spanID),
jaeger.SpanID(parentID),
sampled, baggage), nil
} | [
"func",
"(",
"p",
"Propagator",
")",
"Extract",
"(",
"abstractCarrier",
"interface",
"{",
"}",
")",
"(",
"jaeger",
".",
"SpanContext",
",",
"error",
")",
"{",
"textMapReader",
",",
"ok",
":=",
"abstractCarrier",
".",
"(",
"opentracing",
".",
"TextMapReader",... | // Extract conforms to the Extractor interface for encoding Zipkin HTTP B3 headers | [
"Extract",
"conforms",
"to",
"the",
"Extractor",
"interface",
"for",
"encoding",
"Zipkin",
"HTTP",
"B3",
"headers"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/zipkin/propagation.go#L80-L121 | train |
jaegertracing/jaeger-client-go | log/zap/field.go | Trace | func Trace(ctx context.Context) zapcore.Field {
if ctx == nil {
return zap.Skip()
}
return zap.Object("trace", trace{ctx})
} | go | func Trace(ctx context.Context) zapcore.Field {
if ctx == nil {
return zap.Skip()
}
return zap.Object("trace", trace{ctx})
} | [
"func",
"Trace",
"(",
"ctx",
"context",
".",
"Context",
")",
"zapcore",
".",
"Field",
"{",
"if",
"ctx",
"==",
"nil",
"{",
"return",
"zap",
".",
"Skip",
"(",
")",
"\n",
"}",
"\n",
"return",
"zap",
".",
"Object",
"(",
"\"trace\"",
",",
"trace",
"{",
... | // Trace creates a field that extracts tracing information from a context and
// includes it under the "trace" key.
//
// Because the opentracing APIs don't expose this information, the returned
// zap.Field is a no-op for contexts that don't contain a span or contain a
// non-Jaeger span. | [
"Trace",
"creates",
"a",
"field",
"that",
"extracts",
"tracing",
"information",
"from",
"a",
"context",
"and",
"includes",
"it",
"under",
"the",
"trace",
"key",
".",
"Because",
"the",
"opentracing",
"APIs",
"don",
"t",
"expose",
"this",
"information",
"the",
... | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/log/zap/field.go#L34-L39 | train |
jaegertracing/jaeger-client-go | tracer_options.go | Metrics | func (tracerOptions) Metrics(m *Metrics) TracerOption {
return func(tracer *Tracer) {
tracer.metrics = *m
}
} | go | func (tracerOptions) Metrics(m *Metrics) TracerOption {
return func(tracer *Tracer) {
tracer.metrics = *m
}
} | [
"func",
"(",
"tracerOptions",
")",
"Metrics",
"(",
"m",
"*",
"Metrics",
")",
"TracerOption",
"{",
"return",
"func",
"(",
"tracer",
"*",
"Tracer",
")",
"{",
"tracer",
".",
"metrics",
"=",
"*",
"m",
"\n",
"}",
"\n",
"}"
] | // Metrics creates a TracerOption that initializes Metrics on the tracer,
// which is used to emit statistics. | [
"Metrics",
"creates",
"a",
"TracerOption",
"that",
"initializes",
"Metrics",
"on",
"the",
"tracer",
"which",
"is",
"used",
"to",
"emit",
"statistics",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/tracer_options.go#L36-L40 | train |
jaegertracing/jaeger-client-go | tracer_options.go | Logger | func (tracerOptions) Logger(logger Logger) TracerOption {
return func(tracer *Tracer) {
tracer.logger = logger
}
} | go | func (tracerOptions) Logger(logger Logger) TracerOption {
return func(tracer *Tracer) {
tracer.logger = logger
}
} | [
"func",
"(",
"tracerOptions",
")",
"Logger",
"(",
"logger",
"Logger",
")",
"TracerOption",
"{",
"return",
"func",
"(",
"tracer",
"*",
"Tracer",
")",
"{",
"tracer",
".",
"logger",
"=",
"logger",
"\n",
"}",
"\n",
"}"
] | // Logger creates a TracerOption that gives the tracer a Logger. | [
"Logger",
"creates",
"a",
"TracerOption",
"that",
"gives",
"the",
"tracer",
"a",
"Logger",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/tracer_options.go#L43-L47 | train |
jaegertracing/jaeger-client-go | tracer_options.go | TimeNow | func (tracerOptions) TimeNow(timeNow func() time.Time) TracerOption {
return func(tracer *Tracer) {
tracer.timeNow = timeNow
}
} | go | func (tracerOptions) TimeNow(timeNow func() time.Time) TracerOption {
return func(tracer *Tracer) {
tracer.timeNow = timeNow
}
} | [
"func",
"(",
"tracerOptions",
")",
"TimeNow",
"(",
"timeNow",
"func",
"(",
")",
"time",
".",
"Time",
")",
"TracerOption",
"{",
"return",
"func",
"(",
"tracer",
"*",
"Tracer",
")",
"{",
"tracer",
".",
"timeNow",
"=",
"timeNow",
"\n",
"}",
"\n",
"}"
] | // TimeNow creates a TracerOption that gives the tracer a function
// used to generate timestamps for spans. | [
"TimeNow",
"creates",
"a",
"TracerOption",
"that",
"gives",
"the",
"tracer",
"a",
"function",
"used",
"to",
"generate",
"timestamps",
"for",
"spans",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/tracer_options.go#L64-L68 | train |
jaegertracing/jaeger-client-go | tracer_options.go | RandomNumber | func (tracerOptions) RandomNumber(randomNumber func() uint64) TracerOption {
return func(tracer *Tracer) {
tracer.randomNumber = randomNumber
}
} | go | func (tracerOptions) RandomNumber(randomNumber func() uint64) TracerOption {
return func(tracer *Tracer) {
tracer.randomNumber = randomNumber
}
} | [
"func",
"(",
"tracerOptions",
")",
"RandomNumber",
"(",
"randomNumber",
"func",
"(",
")",
"uint64",
")",
"TracerOption",
"{",
"return",
"func",
"(",
"tracer",
"*",
"Tracer",
")",
"{",
"tracer",
".",
"randomNumber",
"=",
"randomNumber",
"\n",
"}",
"\n",
"}"... | // RandomNumber creates a TracerOption that gives the tracer
// a thread-safe random number generator function for generating trace IDs. | [
"RandomNumber",
"creates",
"a",
"TracerOption",
"that",
"gives",
"the",
"tracer",
"a",
"thread",
"-",
"safe",
"random",
"number",
"generator",
"function",
"for",
"generating",
"trace",
"IDs",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/tracer_options.go#L72-L76 | train |
jaegertracing/jaeger-client-go | tracer_options.go | PoolSpans | func (tracerOptions) PoolSpans(poolSpans bool) TracerOption {
return func(tracer *Tracer) {
if poolSpans {
tracer.spanAllocator = newSyncPollSpanAllocator()
} else {
tracer.spanAllocator = simpleSpanAllocator{}
}
}
} | go | func (tracerOptions) PoolSpans(poolSpans bool) TracerOption {
return func(tracer *Tracer) {
if poolSpans {
tracer.spanAllocator = newSyncPollSpanAllocator()
} else {
tracer.spanAllocator = simpleSpanAllocator{}
}
}
} | [
"func",
"(",
"tracerOptions",
")",
"PoolSpans",
"(",
"poolSpans",
"bool",
")",
"TracerOption",
"{",
"return",
"func",
"(",
"tracer",
"*",
"Tracer",
")",
"{",
"if",
"poolSpans",
"{",
"tracer",
".",
"spanAllocator",
"=",
"newSyncPollSpanAllocator",
"(",
")",
"... | // PoolSpans creates a TracerOption that tells the tracer whether it should use
// an object pool to minimize span allocations.
// This should be used with care, only if the service is not running any async tasks
// that can access parent spans after those spans have been finished. | [
"PoolSpans",
"creates",
"a",
"TracerOption",
"that",
"tells",
"the",
"tracer",
"whether",
"it",
"should",
"use",
"an",
"object",
"pool",
"to",
"minimize",
"span",
"allocations",
".",
"This",
"should",
"be",
"used",
"with",
"care",
"only",
"if",
"the",
"servi... | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/tracer_options.go#L82-L90 | train |
jaegertracing/jaeger-client-go | crossdock/endtoend/handler.go | NewHandler | func NewHandler(agentHostPort string, samplingServerURL string) *Handler {
return &Handler{
agentHostPort: agentHostPort,
samplingServerURL: samplingServerURL,
tracers: make(map[string]opentracing.Tracer),
}
} | go | func NewHandler(agentHostPort string, samplingServerURL string) *Handler {
return &Handler{
agentHostPort: agentHostPort,
samplingServerURL: samplingServerURL,
tracers: make(map[string]opentracing.Tracer),
}
} | [
"func",
"NewHandler",
"(",
"agentHostPort",
"string",
",",
"samplingServerURL",
"string",
")",
"*",
"Handler",
"{",
"return",
"&",
"Handler",
"{",
"agentHostPort",
":",
"agentHostPort",
",",
"samplingServerURL",
":",
"samplingServerURL",
",",
"tracers",
":",
"make... | // NewHandler returns a Handler. | [
"NewHandler",
"returns",
"a",
"Handler",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/crossdock/endtoend/handler.go#L86-L92 | train |
jaegertracing/jaeger-client-go | crossdock/endtoend/handler.go | init | func (h *Handler) init(cfg config.Configuration) error {
if cfg.Sampler != nil && cfg.Sampler.SamplingServerURL == "" {
cfg.Sampler.SamplingServerURL = h.samplingServerURL
}
if cfg.Reporter != nil && cfg.Reporter.LocalAgentHostPort == "" {
cfg.Reporter.LocalAgentHostPort = h.agentHostPort
}
tracer, _, err := cfg.New(common.DefaultTracerServiceName)
if err != nil {
return err
}
h.tracers[cfg.Sampler.Type] = tracer
return nil
} | go | func (h *Handler) init(cfg config.Configuration) error {
if cfg.Sampler != nil && cfg.Sampler.SamplingServerURL == "" {
cfg.Sampler.SamplingServerURL = h.samplingServerURL
}
if cfg.Reporter != nil && cfg.Reporter.LocalAgentHostPort == "" {
cfg.Reporter.LocalAgentHostPort = h.agentHostPort
}
tracer, _, err := cfg.New(common.DefaultTracerServiceName)
if err != nil {
return err
}
h.tracers[cfg.Sampler.Type] = tracer
return nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"init",
"(",
"cfg",
"config",
".",
"Configuration",
")",
"error",
"{",
"if",
"cfg",
".",
"Sampler",
"!=",
"nil",
"&&",
"cfg",
".",
"Sampler",
".",
"SamplingServerURL",
"==",
"\"\"",
"{",
"cfg",
".",
"Sampler",
"... | // init initializes the handler with a tracer | [
"init",
"initializes",
"the",
"handler",
"with",
"a",
"tracer"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/crossdock/endtoend/handler.go#L95-L108 | train |
jaegertracing/jaeger-client-go | crossdock/endtoend/handler.go | GenerateTraces | func (h *Handler) GenerateTraces(w http.ResponseWriter, r *http.Request) {
decoder := json.NewDecoder(r.Body)
var req traceRequest
if err := decoder.Decode(&req); err != nil {
http.Error(w, fmt.Sprintf("JSON payload is invalid: %s", err.Error()), http.StatusBadRequest)
return
}
tracer := h.getTracer(req.Type)
if tracer == nil {
http.Error(w, "Tracer is not initialized", http.StatusInternalServerError)
return
}
generateTraces(tracer, &req)
} | go | func (h *Handler) GenerateTraces(w http.ResponseWriter, r *http.Request) {
decoder := json.NewDecoder(r.Body)
var req traceRequest
if err := decoder.Decode(&req); err != nil {
http.Error(w, fmt.Sprintf("JSON payload is invalid: %s", err.Error()), http.StatusBadRequest)
return
}
tracer := h.getTracer(req.Type)
if tracer == nil {
http.Error(w, "Tracer is not initialized", http.StatusInternalServerError)
return
}
generateTraces(tracer, &req)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GenerateTraces",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"decoder",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
".",
"Body",
")",
"\n",
"var",
"req",
"traceReque... | // GenerateTraces creates traces given the parameters in the request. | [
"GenerateTraces",
"creates",
"traces",
"given",
"the",
"parameters",
"in",
"the",
"request",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/crossdock/endtoend/handler.go#L129-L142 | train |
jaegertracing/jaeger-client-go | utils/http_json.go | GetJSON | func GetJSON(url string, out interface{}) error {
resp, err := http.Get(url)
if err != nil {
return err
}
return ReadJSON(resp, out)
} | go | func GetJSON(url string, out interface{}) error {
resp, err := http.Get(url)
if err != nil {
return err
}
return ReadJSON(resp, out)
} | [
"func",
"GetJSON",
"(",
"url",
"string",
",",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"resp",
",",
"err",
":=",
"http",
".",
"Get",
"(",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"ReadJS... | // GetJSON makes an HTTP call to the specified URL and parses the returned JSON into `out`. | [
"GetJSON",
"makes",
"an",
"HTTP",
"call",
"to",
"the",
"specified",
"URL",
"and",
"parses",
"the",
"returned",
"JSON",
"into",
"out",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/utils/http_json.go#L26-L32 | train |
jaegertracing/jaeger-client-go | utils/http_json.go | ReadJSON | func ReadJSON(resp *http.Response, out interface{}) error {
defer resp.Body.Close()
if resp.StatusCode >= 400 {
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
return fmt.Errorf("StatusCode: %d, Body: %s", resp.StatusCode, body)
}
if out == nil {
io.Copy(ioutil.Discard, resp.Body)
return nil
}
decoder := json.NewDecoder(resp.Body)
return decoder.Decode(out)
} | go | func ReadJSON(resp *http.Response, out interface{}) error {
defer resp.Body.Close()
if resp.StatusCode >= 400 {
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
return fmt.Errorf("StatusCode: %d, Body: %s", resp.StatusCode, body)
}
if out == nil {
io.Copy(ioutil.Discard, resp.Body)
return nil
}
decoder := json.NewDecoder(resp.Body)
return decoder.Decode(out)
} | [
"func",
"ReadJSON",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"resp",
".",
"StatusCode",
">=",
"400",
"{",
"body",
",",
"err",
... | // ReadJSON reads JSON from http.Response and parses it into `out` | [
"ReadJSON",
"reads",
"JSON",
"from",
"http",
".",
"Response",
"and",
"parses",
"it",
"into",
"out"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/utils/http_json.go#L35-L54 | train |
jaegertracing/jaeger-client-go | rpcmetrics/endpoints.go | normalize | func (n *normalizedEndpoints) normalize(name string) string {
n.mux.RLock()
norm, ok := n.names[name]
l := len(n.names)
n.mux.RUnlock()
if ok {
return norm
}
if l >= n.maxSize {
return ""
}
return n.normalizeWithLock(name)
} | go | func (n *normalizedEndpoints) normalize(name string) string {
n.mux.RLock()
norm, ok := n.names[name]
l := len(n.names)
n.mux.RUnlock()
if ok {
return norm
}
if l >= n.maxSize {
return ""
}
return n.normalizeWithLock(name)
} | [
"func",
"(",
"n",
"*",
"normalizedEndpoints",
")",
"normalize",
"(",
"name",
"string",
")",
"string",
"{",
"n",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"norm",
",",
"ok",
":=",
"n",
".",
"names",
"[",
"name",
"]",
"\n",
"l",
":=",
"len",
"(",
... | // normalize looks up the name in the cache, if not found it uses normalizer
// to convert the name to a safe name. If called with more than maxSize unique
// names it returns "" for all other names beyond those already cached. | [
"normalize",
"looks",
"up",
"the",
"name",
"in",
"the",
"cache",
"if",
"not",
"found",
"it",
"uses",
"normalizer",
"to",
"convert",
"the",
"name",
"to",
"a",
"safe",
"name",
".",
"If",
"called",
"with",
"more",
"than",
"maxSize",
"unique",
"names",
"it",... | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/rpcmetrics/endpoints.go#L39-L51 | train |
jaegertracing/jaeger-client-go | reporter_options.go | QueueSize | func (reporterOptions) QueueSize(queueSize int) ReporterOption {
return func(r *reporterOptions) {
r.queueSize = queueSize
}
} | go | func (reporterOptions) QueueSize(queueSize int) ReporterOption {
return func(r *reporterOptions) {
r.queueSize = queueSize
}
} | [
"func",
"(",
"reporterOptions",
")",
"QueueSize",
"(",
"queueSize",
"int",
")",
"ReporterOption",
"{",
"return",
"func",
"(",
"r",
"*",
"reporterOptions",
")",
"{",
"r",
".",
"queueSize",
"=",
"queueSize",
"\n",
"}",
"\n",
"}"
] | // QueueSize creates a ReporterOption that sets the size of the internal queue where
// spans are stored before they are processed. | [
"QueueSize",
"creates",
"a",
"ReporterOption",
"that",
"sets",
"the",
"size",
"of",
"the",
"internal",
"queue",
"where",
"spans",
"are",
"stored",
"before",
"they",
"are",
"processed",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/reporter_options.go#L41-L45 | train |
jaegertracing/jaeger-client-go | reporter_options.go | Metrics | func (reporterOptions) Metrics(metrics *Metrics) ReporterOption {
return func(r *reporterOptions) {
r.metrics = metrics
}
} | go | func (reporterOptions) Metrics(metrics *Metrics) ReporterOption {
return func(r *reporterOptions) {
r.metrics = metrics
}
} | [
"func",
"(",
"reporterOptions",
")",
"Metrics",
"(",
"metrics",
"*",
"Metrics",
")",
"ReporterOption",
"{",
"return",
"func",
"(",
"r",
"*",
"reporterOptions",
")",
"{",
"r",
".",
"metrics",
"=",
"metrics",
"\n",
"}",
"\n",
"}"
] | // Metrics creates a ReporterOption that initializes Metrics in the reporter,
// which is used to record runtime statistics. | [
"Metrics",
"creates",
"a",
"ReporterOption",
"that",
"initializes",
"Metrics",
"in",
"the",
"reporter",
"which",
"is",
"used",
"to",
"record",
"runtime",
"statistics",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/reporter_options.go#L49-L53 | train |
jaegertracing/jaeger-client-go | reporter_options.go | BufferFlushInterval | func (reporterOptions) BufferFlushInterval(bufferFlushInterval time.Duration) ReporterOption {
return func(r *reporterOptions) {
r.bufferFlushInterval = bufferFlushInterval
}
} | go | func (reporterOptions) BufferFlushInterval(bufferFlushInterval time.Duration) ReporterOption {
return func(r *reporterOptions) {
r.bufferFlushInterval = bufferFlushInterval
}
} | [
"func",
"(",
"reporterOptions",
")",
"BufferFlushInterval",
"(",
"bufferFlushInterval",
"time",
".",
"Duration",
")",
"ReporterOption",
"{",
"return",
"func",
"(",
"r",
"*",
"reporterOptions",
")",
"{",
"r",
".",
"bufferFlushInterval",
"=",
"bufferFlushInterval",
... | // BufferFlushInterval creates a ReporterOption that sets how often the queue
// is force-flushed. | [
"BufferFlushInterval",
"creates",
"a",
"ReporterOption",
"that",
"sets",
"how",
"often",
"the",
"queue",
"is",
"force",
"-",
"flushed",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/reporter_options.go#L57-L61 | train |
jaegertracing/jaeger-client-go | reporter_options.go | Logger | func (reporterOptions) Logger(logger Logger) ReporterOption {
return func(r *reporterOptions) {
r.logger = logger
}
} | go | func (reporterOptions) Logger(logger Logger) ReporterOption {
return func(r *reporterOptions) {
r.logger = logger
}
} | [
"func",
"(",
"reporterOptions",
")",
"Logger",
"(",
"logger",
"Logger",
")",
"ReporterOption",
"{",
"return",
"func",
"(",
"r",
"*",
"reporterOptions",
")",
"{",
"r",
".",
"logger",
"=",
"logger",
"\n",
"}",
"\n",
"}"
] | // Logger creates a ReporterOption that initializes the logger used to log
// errors of span submissions. | [
"Logger",
"creates",
"a",
"ReporterOption",
"that",
"initializes",
"the",
"logger",
"used",
"to",
"log",
"errors",
"of",
"span",
"submissions",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/reporter_options.go#L65-L69 | train |
jaegertracing/jaeger-client-go | crossdock/server/server.go | Start | func (s *Server) Start() error {
if s.HostPortHTTP == "" {
s.HostPortHTTP = ":" + common.DefaultServerPortHTTP
}
s.eHandler = endtoend.NewHandler(s.AgentHostPort, s.SamplingServerURL)
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { return }) // health check
mux.HandleFunc("/start_trace", func(w http.ResponseWriter, r *http.Request) {
s.handleJSON(w, r, func() interface{} {
return tracetest.NewStartTraceRequest()
}, func(ctx context.Context, req interface{}) (interface{}, error) {
return s.doStartTrace(req.(*tracetest.StartTraceRequest))
})
})
mux.HandleFunc("/join_trace", func(w http.ResponseWriter, r *http.Request) {
s.handleJSON(w, r, func() interface{} {
return tracetest.NewJoinTraceRequest()
}, func(ctx context.Context, req interface{}) (interface{}, error) {
return s.doJoinTrace(ctx, req.(*tracetest.JoinTraceRequest))
})
})
mux.HandleFunc("/create_traces", s.eHandler.GenerateTraces)
listener, err := net.Listen("tcp", s.HostPortHTTP)
if err != nil {
return err
}
s.listener = listener
s.HostPortHTTP = listener.Addr().String()
var started sync.WaitGroup
started.Add(1)
go func() {
started.Done()
http.Serve(listener, mux)
}()
started.Wait()
log.Printf("Started http server at %s\n", s.HostPortHTTP)
return nil
} | go | func (s *Server) Start() error {
if s.HostPortHTTP == "" {
s.HostPortHTTP = ":" + common.DefaultServerPortHTTP
}
s.eHandler = endtoend.NewHandler(s.AgentHostPort, s.SamplingServerURL)
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { return }) // health check
mux.HandleFunc("/start_trace", func(w http.ResponseWriter, r *http.Request) {
s.handleJSON(w, r, func() interface{} {
return tracetest.NewStartTraceRequest()
}, func(ctx context.Context, req interface{}) (interface{}, error) {
return s.doStartTrace(req.(*tracetest.StartTraceRequest))
})
})
mux.HandleFunc("/join_trace", func(w http.ResponseWriter, r *http.Request) {
s.handleJSON(w, r, func() interface{} {
return tracetest.NewJoinTraceRequest()
}, func(ctx context.Context, req interface{}) (interface{}, error) {
return s.doJoinTrace(ctx, req.(*tracetest.JoinTraceRequest))
})
})
mux.HandleFunc("/create_traces", s.eHandler.GenerateTraces)
listener, err := net.Listen("tcp", s.HostPortHTTP)
if err != nil {
return err
}
s.listener = listener
s.HostPortHTTP = listener.Addr().String()
var started sync.WaitGroup
started.Add(1)
go func() {
started.Done()
http.Serve(listener, mux)
}()
started.Wait()
log.Printf("Started http server at %s\n", s.HostPortHTTP)
return nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Start",
"(",
")",
"error",
"{",
"if",
"s",
".",
"HostPortHTTP",
"==",
"\"\"",
"{",
"s",
".",
"HostPortHTTP",
"=",
"\":\"",
"+",
"common",
".",
"DefaultServerPortHTTP",
"\n",
"}",
"\n",
"s",
".",
"eHandler",
"=",... | // Start starts the test server called by the Client and other upstream servers. | [
"Start",
"starts",
"the",
"test",
"server",
"called",
"by",
"the",
"Client",
"and",
"other",
"upstream",
"servers",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/crossdock/server/server.go#L47-L88 | train |
jaegertracing/jaeger-client-go | crossdock/server/server.go | GetPortHTTP | func (s *Server) GetPortHTTP() string {
hostPort := s.HostPortHTTP
hostPortSplit := strings.Split(hostPort, ":")
port := hostPortSplit[len(hostPortSplit)-1]
return port
} | go | func (s *Server) GetPortHTTP() string {
hostPort := s.HostPortHTTP
hostPortSplit := strings.Split(hostPort, ":")
port := hostPortSplit[len(hostPortSplit)-1]
return port
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"GetPortHTTP",
"(",
")",
"string",
"{",
"hostPort",
":=",
"s",
".",
"HostPortHTTP",
"\n",
"hostPortSplit",
":=",
"strings",
".",
"Split",
"(",
"hostPort",
",",
"\":\"",
")",
"\n",
"port",
":=",
"hostPortSplit",
"[",
... | // GetPortHTTP returns the network port the server listens to. | [
"GetPortHTTP",
"returns",
"the",
"network",
"port",
"the",
"server",
"listens",
"to",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/crossdock/server/server.go#L101-L106 | train |
jaegertracing/jaeger-client-go | rpcmetrics/normalizer.go | IsSafe | func (r *Range) IsSafe(c byte) bool {
return c >= r.From && c <= r.To
} | go | func (r *Range) IsSafe(c byte) bool {
return c >= r.From && c <= r.To
} | [
"func",
"(",
"r",
"*",
"Range",
")",
"IsSafe",
"(",
"c",
"byte",
")",
"bool",
"{",
"return",
"c",
">=",
"r",
".",
"From",
"&&",
"c",
"<=",
"r",
".",
"To",
"\n",
"}"
] | // IsSafe implements SafeCharacterSet | [
"IsSafe",
"implements",
"SafeCharacterSet"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/rpcmetrics/normalizer.go#L55-L57 | train |
jaegertracing/jaeger-client-go | rpcmetrics/normalizer.go | Normalize | func (n *SimpleNameNormalizer) Normalize(name string) string {
var retMe []byte
nameBytes := []byte(name)
for i, b := range nameBytes {
if n.safeByte(b) {
if retMe != nil {
retMe[i] = b
}
} else {
if retMe == nil {
retMe = make([]byte, len(nameBytes))
copy(retMe[0:i], nameBytes[0:i])
}
retMe[i] = n.Replacement
}
}
if retMe == nil {
return name
}
return string(retMe)
} | go | func (n *SimpleNameNormalizer) Normalize(name string) string {
var retMe []byte
nameBytes := []byte(name)
for i, b := range nameBytes {
if n.safeByte(b) {
if retMe != nil {
retMe[i] = b
}
} else {
if retMe == nil {
retMe = make([]byte, len(nameBytes))
copy(retMe[0:i], nameBytes[0:i])
}
retMe[i] = n.Replacement
}
}
if retMe == nil {
return name
}
return string(retMe)
} | [
"func",
"(",
"n",
"*",
"SimpleNameNormalizer",
")",
"Normalize",
"(",
"name",
"string",
")",
"string",
"{",
"var",
"retMe",
"[",
"]",
"byte",
"\n",
"nameBytes",
":=",
"[",
"]",
"byte",
"(",
"name",
")",
"\n",
"for",
"i",
",",
"b",
":=",
"range",
"n... | // Normalize checks each character in the string against SafeSets,
// and if it's not safe substitutes it with Replacement. | [
"Normalize",
"checks",
"each",
"character",
"in",
"the",
"string",
"against",
"SafeSets",
"and",
"if",
"it",
"s",
"not",
"safe",
"substitutes",
"it",
"with",
"Replacement",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/rpcmetrics/normalizer.go#L71-L91 | train |
jaegertracing/jaeger-client-go | rpcmetrics/normalizer.go | safeByte | func (n *SimpleNameNormalizer) safeByte(b byte) bool {
for i := range n.SafeSets {
if n.SafeSets[i].IsSafe(b) {
return true
}
}
return false
} | go | func (n *SimpleNameNormalizer) safeByte(b byte) bool {
for i := range n.SafeSets {
if n.SafeSets[i].IsSafe(b) {
return true
}
}
return false
} | [
"func",
"(",
"n",
"*",
"SimpleNameNormalizer",
")",
"safeByte",
"(",
"b",
"byte",
")",
"bool",
"{",
"for",
"i",
":=",
"range",
"n",
".",
"SafeSets",
"{",
"if",
"n",
".",
"SafeSets",
"[",
"i",
"]",
".",
"IsSafe",
"(",
"b",
")",
"{",
"return",
"tru... | // safeByte checks if b against all safe charsets. | [
"safeByte",
"checks",
"if",
"b",
"against",
"all",
"safe",
"charsets",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/rpcmetrics/normalizer.go#L94-L101 | train |
jaegertracing/jaeger-client-go | reporter.go | SpansSubmitted | func (r *InMemoryReporter) SpansSubmitted() int {
r.lock.Lock()
defer r.lock.Unlock()
return len(r.spans)
} | go | func (r *InMemoryReporter) SpansSubmitted() int {
r.lock.Lock()
defer r.lock.Unlock()
return len(r.spans)
} | [
"func",
"(",
"r",
"*",
"InMemoryReporter",
")",
"SpansSubmitted",
"(",
")",
"int",
"{",
"r",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"len",
"(",
"r",
".",
"spans",
")",
"\n",
... | // SpansSubmitted returns the number of spans accumulated in the buffer. | [
"SpansSubmitted",
"returns",
"the",
"number",
"of",
"spans",
"accumulated",
"in",
"the",
"buffer",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/reporter.go#L107-L111 | train |
jaegertracing/jaeger-client-go | reporter.go | GetSpans | func (r *InMemoryReporter) GetSpans() []opentracing.Span {
r.lock.Lock()
defer r.lock.Unlock()
copied := make([]opentracing.Span, len(r.spans))
copy(copied, r.spans)
return copied
} | go | func (r *InMemoryReporter) GetSpans() []opentracing.Span {
r.lock.Lock()
defer r.lock.Unlock()
copied := make([]opentracing.Span, len(r.spans))
copy(copied, r.spans)
return copied
} | [
"func",
"(",
"r",
"*",
"InMemoryReporter",
")",
"GetSpans",
"(",
")",
"[",
"]",
"opentracing",
".",
"Span",
"{",
"r",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"copied",
":=",
"make",
"(",... | // GetSpans returns accumulated spans as a copy of the buffer. | [
"GetSpans",
"returns",
"accumulated",
"spans",
"as",
"a",
"copy",
"of",
"the",
"buffer",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/reporter.go#L114-L120 | train |
jaegertracing/jaeger-client-go | reporter.go | Reset | func (r *InMemoryReporter) Reset() {
r.lock.Lock()
defer r.lock.Unlock()
// Before reset the collection need to release Span memory
for _, span := range r.spans {
span.(*Span).Release()
}
r.spans = r.spans[:0]
} | go | func (r *InMemoryReporter) Reset() {
r.lock.Lock()
defer r.lock.Unlock()
// Before reset the collection need to release Span memory
for _, span := range r.spans {
span.(*Span).Release()
}
r.spans = r.spans[:0]
} | [
"func",
"(",
"r",
"*",
"InMemoryReporter",
")",
"Reset",
"(",
")",
"{",
"r",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"span",
":=",
"range",
"r",
".",
"spans",
"{",
"... | // Reset clears all accumulated spans. | [
"Reset",
"clears",
"all",
"accumulated",
"spans",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/reporter.go#L123-L132 | train |
jaegertracing/jaeger-client-go | reporter.go | processQueue | func (r *remoteReporter) processQueue() {
// flush causes the Sender to flush its accumulated spans and clear the buffer
flush := func() {
if flushed, err := r.sender.Flush(); err != nil {
r.metrics.ReporterFailure.Inc(int64(flushed))
r.logger.Error(fmt.Sprintf("error when flushing the buffer: %s", err.Error()))
} else if flushed > 0 {
r.metrics.ReporterSuccess.Inc(int64(flushed))
}
}
timer := time.NewTicker(r.bufferFlushInterval)
for {
select {
case <-timer.C:
flush()
case item := <-r.queue:
atomic.AddInt64(&r.queueLength, -1)
switch item.itemType {
case reporterQueueItemSpan:
span := item.span
if flushed, err := r.sender.Append(span); err != nil {
r.metrics.ReporterFailure.Inc(int64(flushed))
r.logger.Error(fmt.Sprintf("error reporting span %q: %s", span.OperationName(), err.Error()))
} else if flushed > 0 {
r.metrics.ReporterSuccess.Inc(int64(flushed))
// to reduce the number of gauge stats, we only emit queue length on flush
r.metrics.ReporterQueueLength.Update(atomic.LoadInt64(&r.queueLength))
}
span.Release()
case reporterQueueItemClose:
timer.Stop()
flush()
item.close.Done()
return
}
}
}
} | go | func (r *remoteReporter) processQueue() {
// flush causes the Sender to flush its accumulated spans and clear the buffer
flush := func() {
if flushed, err := r.sender.Flush(); err != nil {
r.metrics.ReporterFailure.Inc(int64(flushed))
r.logger.Error(fmt.Sprintf("error when flushing the buffer: %s", err.Error()))
} else if flushed > 0 {
r.metrics.ReporterSuccess.Inc(int64(flushed))
}
}
timer := time.NewTicker(r.bufferFlushInterval)
for {
select {
case <-timer.C:
flush()
case item := <-r.queue:
atomic.AddInt64(&r.queueLength, -1)
switch item.itemType {
case reporterQueueItemSpan:
span := item.span
if flushed, err := r.sender.Append(span); err != nil {
r.metrics.ReporterFailure.Inc(int64(flushed))
r.logger.Error(fmt.Sprintf("error reporting span %q: %s", span.OperationName(), err.Error()))
} else if flushed > 0 {
r.metrics.ReporterSuccess.Inc(int64(flushed))
// to reduce the number of gauge stats, we only emit queue length on flush
r.metrics.ReporterQueueLength.Update(atomic.LoadInt64(&r.queueLength))
}
span.Release()
case reporterQueueItemClose:
timer.Stop()
flush()
item.close.Done()
return
}
}
}
} | [
"func",
"(",
"r",
"*",
"remoteReporter",
")",
"processQueue",
"(",
")",
"{",
"flush",
":=",
"func",
"(",
")",
"{",
"if",
"flushed",
",",
"err",
":=",
"r",
".",
"sender",
".",
"Flush",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"r",
".",
"metrics",
... | // processQueue reads spans from the queue, converts them to Thrift, and stores them in an internal buffer.
// When the buffer length reaches batchSize, it is flushed by submitting the accumulated spans to Jaeger.
// Buffer also gets flushed automatically every batchFlushInterval seconds, just in case the tracer stopped
// reporting new spans. | [
"processQueue",
"reads",
"spans",
"from",
"the",
"queue",
"converts",
"them",
"to",
"Thrift",
"and",
"stores",
"them",
"in",
"an",
"internal",
"buffer",
".",
"When",
"the",
"buffer",
"length",
"reaches",
"batchSize",
"it",
"is",
"flushed",
"by",
"submitting",
... | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/reporter.go#L259-L297 | train |
jaegertracing/jaeger-client-go | tracer.go | addCodec | func (t *Tracer) addCodec(format interface{}, injector Injector, extractor Extractor) {
if _, ok := t.injectors[format]; !ok {
t.injectors[format] = injector
}
if _, ok := t.extractors[format]; !ok {
t.extractors[format] = extractor
}
} | go | func (t *Tracer) addCodec(format interface{}, injector Injector, extractor Extractor) {
if _, ok := t.injectors[format]; !ok {
t.injectors[format] = injector
}
if _, ok := t.extractors[format]; !ok {
t.extractors[format] = extractor
}
} | [
"func",
"(",
"t",
"*",
"Tracer",
")",
"addCodec",
"(",
"format",
"interface",
"{",
"}",
",",
"injector",
"Injector",
",",
"extractor",
"Extractor",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"t",
".",
"injectors",
"[",
"format",
"]",
";",
"!",
"ok",
"{"... | // addCodec adds registers injector and extractor for given propagation format if not already defined. | [
"addCodec",
"adds",
"registers",
"injector",
"and",
"extractor",
"for",
"given",
"propagation",
"format",
"if",
"not",
"already",
"defined",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/tracer.go#L179-L186 | train |
jaegertracing/jaeger-client-go | tracer.go | Close | func (t *Tracer) Close() error {
t.reporter.Close()
t.sampler.Close()
if mgr, ok := t.baggageRestrictionManager.(io.Closer); ok {
mgr.Close()
}
if throttler, ok := t.debugThrottler.(io.Closer); ok {
throttler.Close()
}
return nil
} | go | func (t *Tracer) Close() error {
t.reporter.Close()
t.sampler.Close()
if mgr, ok := t.baggageRestrictionManager.(io.Closer); ok {
mgr.Close()
}
if throttler, ok := t.debugThrottler.(io.Closer); ok {
throttler.Close()
}
return nil
} | [
"func",
"(",
"t",
"*",
"Tracer",
")",
"Close",
"(",
")",
"error",
"{",
"t",
".",
"reporter",
".",
"Close",
"(",
")",
"\n",
"t",
".",
"sampler",
".",
"Close",
"(",
")",
"\n",
"if",
"mgr",
",",
"ok",
":=",
"t",
".",
"baggageRestrictionManager",
"."... | // Close releases all resources used by the Tracer and flushes any remaining buffered spans. | [
"Close",
"releases",
"all",
"resources",
"used",
"by",
"the",
"Tracer",
"and",
"flushes",
"any",
"remaining",
"buffered",
"spans",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/tracer.go#L329-L339 | train |
jaegertracing/jaeger-client-go | tracer.go | Tags | func (t *Tracer) Tags() []opentracing.Tag {
tags := make([]opentracing.Tag, len(t.tags))
for i, tag := range t.tags {
tags[i] = opentracing.Tag{Key: tag.key, Value: tag.value}
}
return tags
} | go | func (t *Tracer) Tags() []opentracing.Tag {
tags := make([]opentracing.Tag, len(t.tags))
for i, tag := range t.tags {
tags[i] = opentracing.Tag{Key: tag.key, Value: tag.value}
}
return tags
} | [
"func",
"(",
"t",
"*",
"Tracer",
")",
"Tags",
"(",
")",
"[",
"]",
"opentracing",
".",
"Tag",
"{",
"tags",
":=",
"make",
"(",
"[",
"]",
"opentracing",
".",
"Tag",
",",
"len",
"(",
"t",
".",
"tags",
")",
")",
"\n",
"for",
"i",
",",
"tag",
":=",... | // Tags returns a slice of tracer-level tags. | [
"Tags",
"returns",
"a",
"slice",
"of",
"tracer",
"-",
"level",
"tags",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/tracer.go#L342-L348 | train |
jaegertracing/jaeger-client-go | transport/zipkin/http.go | HTTPLogger | func HTTPLogger(logger jaeger.Logger) HTTPOption {
return func(c *HTTPTransport) { c.logger = logger }
} | go | func HTTPLogger(logger jaeger.Logger) HTTPOption {
return func(c *HTTPTransport) { c.logger = logger }
} | [
"func",
"HTTPLogger",
"(",
"logger",
"jaeger",
".",
"Logger",
")",
"HTTPOption",
"{",
"return",
"func",
"(",
"c",
"*",
"HTTPTransport",
")",
"{",
"c",
".",
"logger",
"=",
"logger",
"}",
"\n",
"}"
] | // HTTPLogger sets the logger used to report errors in the collection
// process. By default, a no-op logger is used, i.e. no errors are logged
// anywhere. It's important to set this option in a production service. | [
"HTTPLogger",
"sets",
"the",
"logger",
"used",
"to",
"report",
"errors",
"in",
"the",
"collection",
"process",
".",
"By",
"default",
"a",
"no",
"-",
"op",
"logger",
"is",
"used",
"i",
".",
"e",
".",
"no",
"errors",
"are",
"logged",
"anywhere",
".",
"It... | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/transport/zipkin/http.go#L67-L69 | train |
jaegertracing/jaeger-client-go | sampler.go | NewConstSampler | func NewConstSampler(sample bool) Sampler {
tags := []Tag{
{key: SamplerTypeTagKey, value: SamplerTypeConst},
{key: SamplerParamTagKey, value: sample},
}
return &ConstSampler{Decision: sample, tags: tags}
} | go | func NewConstSampler(sample bool) Sampler {
tags := []Tag{
{key: SamplerTypeTagKey, value: SamplerTypeConst},
{key: SamplerParamTagKey, value: sample},
}
return &ConstSampler{Decision: sample, tags: tags}
} | [
"func",
"NewConstSampler",
"(",
"sample",
"bool",
")",
"Sampler",
"{",
"tags",
":=",
"[",
"]",
"Tag",
"{",
"{",
"key",
":",
"SamplerTypeTagKey",
",",
"value",
":",
"SamplerTypeConst",
"}",
",",
"{",
"key",
":",
"SamplerParamTagKey",
",",
"value",
":",
"s... | // NewConstSampler creates a ConstSampler. | [
"NewConstSampler",
"creates",
"a",
"ConstSampler",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/sampler.go#L66-L72 | train |
jaegertracing/jaeger-client-go | sampler.go | NewRateLimitingSampler | func NewRateLimitingSampler(maxTracesPerSecond float64) Sampler {
tags := []Tag{
{key: SamplerTypeTagKey, value: SamplerTypeRateLimiting},
{key: SamplerParamTagKey, value: maxTracesPerSecond},
}
return &rateLimitingSampler{
maxTracesPerSecond: maxTracesPerSecond,
rateLimiter: utils.NewRateLimiter(maxTracesPerSecond, math.Max(maxTracesPerSecond, 1.0)),
tags: tags,
}
} | go | func NewRateLimitingSampler(maxTracesPerSecond float64) Sampler {
tags := []Tag{
{key: SamplerTypeTagKey, value: SamplerTypeRateLimiting},
{key: SamplerParamTagKey, value: maxTracesPerSecond},
}
return &rateLimitingSampler{
maxTracesPerSecond: maxTracesPerSecond,
rateLimiter: utils.NewRateLimiter(maxTracesPerSecond, math.Max(maxTracesPerSecond, 1.0)),
tags: tags,
}
} | [
"func",
"NewRateLimitingSampler",
"(",
"maxTracesPerSecond",
"float64",
")",
"Sampler",
"{",
"tags",
":=",
"[",
"]",
"Tag",
"{",
"{",
"key",
":",
"SamplerTypeTagKey",
",",
"value",
":",
"SamplerTypeRateLimiting",
"}",
",",
"{",
"key",
":",
"SamplerParamTagKey",
... | // NewRateLimitingSampler creates a sampler that samples at most maxTracesPerSecond. The distribution of sampled
// traces follows burstiness of the service, i.e. a service with uniformly distributed requests will have those
// requests sampled uniformly as well, but if requests are bursty, especially sub-second, then a number of
// sequential requests can be sampled each second. | [
"NewRateLimitingSampler",
"creates",
"a",
"sampler",
"that",
"samples",
"at",
"most",
"maxTracesPerSecond",
".",
"The",
"distribution",
"of",
"sampled",
"traces",
"follows",
"burstiness",
"of",
"the",
"service",
"i",
".",
"e",
".",
"a",
"service",
"with",
"unifo... | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/sampler.go#L165-L175 | train |
jaegertracing/jaeger-client-go | sampler.go | NewGuaranteedThroughputProbabilisticSampler | func NewGuaranteedThroughputProbabilisticSampler(
lowerBound, samplingRate float64,
) (*GuaranteedThroughputProbabilisticSampler, error) {
return newGuaranteedThroughputProbabilisticSampler(lowerBound, samplingRate), nil
} | go | func NewGuaranteedThroughputProbabilisticSampler(
lowerBound, samplingRate float64,
) (*GuaranteedThroughputProbabilisticSampler, error) {
return newGuaranteedThroughputProbabilisticSampler(lowerBound, samplingRate), nil
} | [
"func",
"NewGuaranteedThroughputProbabilisticSampler",
"(",
"lowerBound",
",",
"samplingRate",
"float64",
",",
")",
"(",
"*",
"GuaranteedThroughputProbabilisticSampler",
",",
"error",
")",
"{",
"return",
"newGuaranteedThroughputProbabilisticSampler",
"(",
"lowerBound",
",",
... | // NewGuaranteedThroughputProbabilisticSampler returns a delegating sampler that applies both
// probabilisticSampler and rateLimitingSampler. | [
"NewGuaranteedThroughputProbabilisticSampler",
"returns",
"a",
"delegating",
"sampler",
"that",
"applies",
"both",
"probabilisticSampler",
"and",
"rateLimitingSampler",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/sampler.go#L212-L216 | train |
jaegertracing/jaeger-client-go | sampler.go | NewAdaptiveSampler | func NewAdaptiveSampler(strategies *sampling.PerOperationSamplingStrategies, maxOperations int) (Sampler, error) {
return newAdaptiveSampler(strategies, maxOperations), nil
} | go | func NewAdaptiveSampler(strategies *sampling.PerOperationSamplingStrategies, maxOperations int) (Sampler, error) {
return newAdaptiveSampler(strategies, maxOperations), nil
} | [
"func",
"NewAdaptiveSampler",
"(",
"strategies",
"*",
"sampling",
".",
"PerOperationSamplingStrategies",
",",
"maxOperations",
"int",
")",
"(",
"Sampler",
",",
"error",
")",
"{",
"return",
"newAdaptiveSampler",
"(",
"strategies",
",",
"maxOperations",
")",
",",
"n... | // NewAdaptiveSampler returns a delegating sampler that applies both probabilisticSampler and
// rateLimitingSampler via the guaranteedThroughputProbabilisticSampler. This sampler keeps track of all
// operations and delegates calls to the respective guaranteedThroughputProbabilisticSampler. | [
"NewAdaptiveSampler",
"returns",
"a",
"delegating",
"sampler",
"that",
"applies",
"both",
"probabilisticSampler",
"and",
"rateLimitingSampler",
"via",
"the",
"guaranteedThroughputProbabilisticSampler",
".",
"This",
"sampler",
"keeps",
"track",
"of",
"all",
"operations",
"... | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/sampler.go#L284-L286 | train |
jaegertracing/jaeger-client-go | header.go | ApplyDefaults | func (c *HeadersConfig) ApplyDefaults() *HeadersConfig {
if c.JaegerBaggageHeader == "" {
c.JaegerBaggageHeader = JaegerBaggageHeader
}
if c.JaegerDebugHeader == "" {
c.JaegerDebugHeader = JaegerDebugHeader
}
if c.TraceBaggageHeaderPrefix == "" {
c.TraceBaggageHeaderPrefix = TraceBaggageHeaderPrefix
}
if c.TraceContextHeaderName == "" {
c.TraceContextHeaderName = TraceContextHeaderName
}
return c
} | go | func (c *HeadersConfig) ApplyDefaults() *HeadersConfig {
if c.JaegerBaggageHeader == "" {
c.JaegerBaggageHeader = JaegerBaggageHeader
}
if c.JaegerDebugHeader == "" {
c.JaegerDebugHeader = JaegerDebugHeader
}
if c.TraceBaggageHeaderPrefix == "" {
c.TraceBaggageHeaderPrefix = TraceBaggageHeaderPrefix
}
if c.TraceContextHeaderName == "" {
c.TraceContextHeaderName = TraceContextHeaderName
}
return c
} | [
"func",
"(",
"c",
"*",
"HeadersConfig",
")",
"ApplyDefaults",
"(",
")",
"*",
"HeadersConfig",
"{",
"if",
"c",
".",
"JaegerBaggageHeader",
"==",
"\"\"",
"{",
"c",
".",
"JaegerBaggageHeader",
"=",
"JaegerBaggageHeader",
"\n",
"}",
"\n",
"if",
"c",
".",
"Jaeg... | // ApplyDefaults sets missing configuration keys to default values | [
"ApplyDefaults",
"sets",
"missing",
"configuration",
"keys",
"to",
"default",
"values"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/header.go#L42-L56 | train |
jaegertracing/jaeger-client-go | log/logger.go | Infof | func (l *BytesBufferLogger) Infof(msg string, args ...interface{}) {
l.mux.Lock()
l.buf.WriteString("INFO: " + fmt.Sprintf(msg, args...) + "\n")
l.mux.Unlock()
} | go | func (l *BytesBufferLogger) Infof(msg string, args ...interface{}) {
l.mux.Lock()
l.buf.WriteString("INFO: " + fmt.Sprintf(msg, args...) + "\n")
l.mux.Unlock()
} | [
"func",
"(",
"l",
"*",
"BytesBufferLogger",
")",
"Infof",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"l",
".",
"buf",
".",
"WriteString",
"(",
"\"INFO: \"",
"+",
"fmt",
... | // Infof implements Logger. | [
"Infof",
"implements",
"Logger",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/log/logger.go#L72-L76 | train |
jaegertracing/jaeger-client-go | log/logger.go | String | func (l *BytesBufferLogger) String() string {
l.mux.Lock()
defer l.mux.Unlock()
return l.buf.String()
} | go | func (l *BytesBufferLogger) String() string {
l.mux.Lock()
defer l.mux.Unlock()
return l.buf.String()
} | [
"func",
"(",
"l",
"*",
"BytesBufferLogger",
")",
"String",
"(",
")",
"string",
"{",
"l",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n",
"return",
"l",
".",
"buf",
".",
"String",
"(",
")",
"\n",... | // String returns string representation of the underlying buffer. | [
"String",
"returns",
"string",
"representation",
"of",
"the",
"underlying",
"buffer",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/log/logger.go#L79-L83 | train |
jaegertracing/jaeger-client-go | log/logger.go | Flush | func (l *BytesBufferLogger) Flush() {
l.mux.Lock()
defer l.mux.Unlock()
l.buf.Reset()
} | go | func (l *BytesBufferLogger) Flush() {
l.mux.Lock()
defer l.mux.Unlock()
l.buf.Reset()
} | [
"func",
"(",
"l",
"*",
"BytesBufferLogger",
")",
"Flush",
"(",
")",
"{",
"l",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n",
"l",
".",
"buf",
".",
"Reset",
"(",
")",
"\n",
"}"
] | // Flush empties the underlying buffer. | [
"Flush",
"empties",
"the",
"underlying",
"buffer",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/log/logger.go#L86-L90 | train |
jaegertracing/jaeger-client-go | config/config.go | InitGlobalTracer | func (c Configuration) InitGlobalTracer(
serviceName string,
options ...Option,
) (io.Closer, error) {
if c.Disabled {
return &nullCloser{}, nil
}
tracer, closer, err := c.New(serviceName, options...)
if err != nil {
return nil, err
}
opentracing.SetGlobalTracer(tracer)
return closer, nil
} | go | func (c Configuration) InitGlobalTracer(
serviceName string,
options ...Option,
) (io.Closer, error) {
if c.Disabled {
return &nullCloser{}, nil
}
tracer, closer, err := c.New(serviceName, options...)
if err != nil {
return nil, err
}
opentracing.SetGlobalTracer(tracer)
return closer, nil
} | [
"func",
"(",
"c",
"Configuration",
")",
"InitGlobalTracer",
"(",
"serviceName",
"string",
",",
"options",
"...",
"Option",
",",
")",
"(",
"io",
".",
"Closer",
",",
"error",
")",
"{",
"if",
"c",
".",
"Disabled",
"{",
"return",
"&",
"nullCloser",
"{",
"}... | // InitGlobalTracer creates a new Jaeger Tracer, and sets it as global OpenTracing Tracer.
// It returns a closer func that can be used to flush buffers before shutdown. | [
"InitGlobalTracer",
"creates",
"a",
"new",
"Jaeger",
"Tracer",
"and",
"sets",
"it",
"as",
"global",
"OpenTracing",
"Tracer",
".",
"It",
"returns",
"a",
"closer",
"func",
"that",
"can",
"be",
"used",
"to",
"flush",
"buffers",
"before",
"shutdown",
"."
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/config/config.go#L304-L317 | train |
jaegertracing/jaeger-client-go | config/config.go | NewSampler | func (sc *SamplerConfig) NewSampler(
serviceName string,
metrics *jaeger.Metrics,
) (jaeger.Sampler, error) {
samplerType := strings.ToLower(sc.Type)
if samplerType == jaeger.SamplerTypeConst {
return jaeger.NewConstSampler(sc.Param != 0), nil
}
if samplerType == jaeger.SamplerTypeProbabilistic {
if sc.Param >= 0 && sc.Param <= 1.0 {
return jaeger.NewProbabilisticSampler(sc.Param)
}
return nil, fmt.Errorf(
"Invalid Param for probabilistic sampler: %v. Expecting value between 0 and 1",
sc.Param,
)
}
if samplerType == jaeger.SamplerTypeRateLimiting {
return jaeger.NewRateLimitingSampler(sc.Param), nil
}
if samplerType == jaeger.SamplerTypeRemote || sc.Type == "" {
sc2 := *sc
sc2.Type = jaeger.SamplerTypeProbabilistic
initSampler, err := sc2.NewSampler(serviceName, nil)
if err != nil {
return nil, err
}
options := []jaeger.SamplerOption{
jaeger.SamplerOptions.Metrics(metrics),
jaeger.SamplerOptions.InitialSampler(initSampler),
jaeger.SamplerOptions.SamplingServerURL(sc.SamplingServerURL),
}
if sc.MaxOperations != 0 {
options = append(options, jaeger.SamplerOptions.MaxOperations(sc.MaxOperations))
}
if sc.SamplingRefreshInterval != 0 {
options = append(options, jaeger.SamplerOptions.SamplingRefreshInterval(sc.SamplingRefreshInterval))
}
return jaeger.NewRemotelyControlledSampler(serviceName, options...), nil
}
return nil, fmt.Errorf("Unknown sampler type %v", sc.Type)
} | go | func (sc *SamplerConfig) NewSampler(
serviceName string,
metrics *jaeger.Metrics,
) (jaeger.Sampler, error) {
samplerType := strings.ToLower(sc.Type)
if samplerType == jaeger.SamplerTypeConst {
return jaeger.NewConstSampler(sc.Param != 0), nil
}
if samplerType == jaeger.SamplerTypeProbabilistic {
if sc.Param >= 0 && sc.Param <= 1.0 {
return jaeger.NewProbabilisticSampler(sc.Param)
}
return nil, fmt.Errorf(
"Invalid Param for probabilistic sampler: %v. Expecting value between 0 and 1",
sc.Param,
)
}
if samplerType == jaeger.SamplerTypeRateLimiting {
return jaeger.NewRateLimitingSampler(sc.Param), nil
}
if samplerType == jaeger.SamplerTypeRemote || sc.Type == "" {
sc2 := *sc
sc2.Type = jaeger.SamplerTypeProbabilistic
initSampler, err := sc2.NewSampler(serviceName, nil)
if err != nil {
return nil, err
}
options := []jaeger.SamplerOption{
jaeger.SamplerOptions.Metrics(metrics),
jaeger.SamplerOptions.InitialSampler(initSampler),
jaeger.SamplerOptions.SamplingServerURL(sc.SamplingServerURL),
}
if sc.MaxOperations != 0 {
options = append(options, jaeger.SamplerOptions.MaxOperations(sc.MaxOperations))
}
if sc.SamplingRefreshInterval != 0 {
options = append(options, jaeger.SamplerOptions.SamplingRefreshInterval(sc.SamplingRefreshInterval))
}
return jaeger.NewRemotelyControlledSampler(serviceName, options...), nil
}
return nil, fmt.Errorf("Unknown sampler type %v", sc.Type)
} | [
"func",
"(",
"sc",
"*",
"SamplerConfig",
")",
"NewSampler",
"(",
"serviceName",
"string",
",",
"metrics",
"*",
"jaeger",
".",
"Metrics",
",",
")",
"(",
"jaeger",
".",
"Sampler",
",",
"error",
")",
"{",
"samplerType",
":=",
"strings",
".",
"ToLower",
"(",... | // NewSampler creates a new sampler based on the configuration | [
"NewSampler",
"creates",
"a",
"new",
"sampler",
"based",
"on",
"the",
"configuration"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/config/config.go#L320-L361 | train |
jaegertracing/jaeger-client-go | config/config.go | NewReporter | func (rc *ReporterConfig) NewReporter(
serviceName string,
metrics *jaeger.Metrics,
logger jaeger.Logger,
) (jaeger.Reporter, error) {
sender, err := rc.newTransport()
if err != nil {
return nil, err
}
reporter := jaeger.NewRemoteReporter(
sender,
jaeger.ReporterOptions.QueueSize(rc.QueueSize),
jaeger.ReporterOptions.BufferFlushInterval(rc.BufferFlushInterval),
jaeger.ReporterOptions.Logger(logger),
jaeger.ReporterOptions.Metrics(metrics))
if rc.LogSpans && logger != nil {
logger.Infof("Initializing logging reporter\n")
reporter = jaeger.NewCompositeReporter(jaeger.NewLoggingReporter(logger), reporter)
}
return reporter, err
} | go | func (rc *ReporterConfig) NewReporter(
serviceName string,
metrics *jaeger.Metrics,
logger jaeger.Logger,
) (jaeger.Reporter, error) {
sender, err := rc.newTransport()
if err != nil {
return nil, err
}
reporter := jaeger.NewRemoteReporter(
sender,
jaeger.ReporterOptions.QueueSize(rc.QueueSize),
jaeger.ReporterOptions.BufferFlushInterval(rc.BufferFlushInterval),
jaeger.ReporterOptions.Logger(logger),
jaeger.ReporterOptions.Metrics(metrics))
if rc.LogSpans && logger != nil {
logger.Infof("Initializing logging reporter\n")
reporter = jaeger.NewCompositeReporter(jaeger.NewLoggingReporter(logger), reporter)
}
return reporter, err
} | [
"func",
"(",
"rc",
"*",
"ReporterConfig",
")",
"NewReporter",
"(",
"serviceName",
"string",
",",
"metrics",
"*",
"jaeger",
".",
"Metrics",
",",
"logger",
"jaeger",
".",
"Logger",
",",
")",
"(",
"jaeger",
".",
"Reporter",
",",
"error",
")",
"{",
"sender",... | // NewReporter instantiates a new reporter that submits spans to the collector | [
"NewReporter",
"instantiates",
"a",
"new",
"reporter",
"that",
"submits",
"spans",
"to",
"the",
"collector"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/config/config.go#L364-L384 | train |
jaegertracing/jaeger-client-go | config/config_env.go | FromEnv | func FromEnv() (*Configuration, error) {
c := &Configuration{}
if e := os.Getenv(envServiceName); e != "" {
c.ServiceName = e
}
if e := os.Getenv(envRPCMetrics); e != "" {
if value, err := strconv.ParseBool(e); err == nil {
c.RPCMetrics = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envRPCMetrics, e)
}
}
if e := os.Getenv(envDisabled); e != "" {
if value, err := strconv.ParseBool(e); err == nil {
c.Disabled = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envDisabled, e)
}
}
if e := os.Getenv(envTags); e != "" {
c.Tags = parseTags(e)
}
if s, err := samplerConfigFromEnv(); err == nil {
c.Sampler = s
} else {
return nil, errors.Wrap(err, "cannot obtain sampler config from env")
}
if r, err := reporterConfigFromEnv(); err == nil {
c.Reporter = r
} else {
return nil, errors.Wrap(err, "cannot obtain reporter config from env")
}
return c, nil
} | go | func FromEnv() (*Configuration, error) {
c := &Configuration{}
if e := os.Getenv(envServiceName); e != "" {
c.ServiceName = e
}
if e := os.Getenv(envRPCMetrics); e != "" {
if value, err := strconv.ParseBool(e); err == nil {
c.RPCMetrics = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envRPCMetrics, e)
}
}
if e := os.Getenv(envDisabled); e != "" {
if value, err := strconv.ParseBool(e); err == nil {
c.Disabled = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envDisabled, e)
}
}
if e := os.Getenv(envTags); e != "" {
c.Tags = parseTags(e)
}
if s, err := samplerConfigFromEnv(); err == nil {
c.Sampler = s
} else {
return nil, errors.Wrap(err, "cannot obtain sampler config from env")
}
if r, err := reporterConfigFromEnv(); err == nil {
c.Reporter = r
} else {
return nil, errors.Wrap(err, "cannot obtain reporter config from env")
}
return c, nil
} | [
"func",
"FromEnv",
"(",
")",
"(",
"*",
"Configuration",
",",
"error",
")",
"{",
"c",
":=",
"&",
"Configuration",
"{",
"}",
"\n",
"if",
"e",
":=",
"os",
".",
"Getenv",
"(",
"envServiceName",
")",
";",
"e",
"!=",
"\"\"",
"{",
"c",
".",
"ServiceName",... | // FromEnv uses environment variables to set the tracer's Configuration | [
"FromEnv",
"uses",
"environment",
"variables",
"to",
"set",
"the",
"tracer",
"s",
"Configuration"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/config/config_env.go#L53-L93 | train |
jaegertracing/jaeger-client-go | config/config_env.go | samplerConfigFromEnv | func samplerConfigFromEnv() (*SamplerConfig, error) {
sc := &SamplerConfig{}
if e := os.Getenv(envSamplerType); e != "" {
sc.Type = e
}
if e := os.Getenv(envSamplerParam); e != "" {
if value, err := strconv.ParseFloat(e, 64); err == nil {
sc.Param = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerParam, e)
}
}
if e := os.Getenv(envSamplerManagerHostPort); e != "" {
sc.SamplingServerURL = e
}
if e := os.Getenv(envSamplerMaxOperations); e != "" {
if value, err := strconv.ParseInt(e, 10, 0); err == nil {
sc.MaxOperations = int(value)
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerMaxOperations, e)
}
}
if e := os.Getenv(envSamplerRefreshInterval); e != "" {
if value, err := time.ParseDuration(e); err == nil {
sc.SamplingRefreshInterval = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerRefreshInterval, e)
}
}
return sc, nil
} | go | func samplerConfigFromEnv() (*SamplerConfig, error) {
sc := &SamplerConfig{}
if e := os.Getenv(envSamplerType); e != "" {
sc.Type = e
}
if e := os.Getenv(envSamplerParam); e != "" {
if value, err := strconv.ParseFloat(e, 64); err == nil {
sc.Param = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerParam, e)
}
}
if e := os.Getenv(envSamplerManagerHostPort); e != "" {
sc.SamplingServerURL = e
}
if e := os.Getenv(envSamplerMaxOperations); e != "" {
if value, err := strconv.ParseInt(e, 10, 0); err == nil {
sc.MaxOperations = int(value)
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerMaxOperations, e)
}
}
if e := os.Getenv(envSamplerRefreshInterval); e != "" {
if value, err := time.ParseDuration(e); err == nil {
sc.SamplingRefreshInterval = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerRefreshInterval, e)
}
}
return sc, nil
} | [
"func",
"samplerConfigFromEnv",
"(",
")",
"(",
"*",
"SamplerConfig",
",",
"error",
")",
"{",
"sc",
":=",
"&",
"SamplerConfig",
"{",
"}",
"\n",
"if",
"e",
":=",
"os",
".",
"Getenv",
"(",
"envSamplerType",
")",
";",
"e",
"!=",
"\"\"",
"{",
"sc",
".",
... | // samplerConfigFromEnv creates a new SamplerConfig based on the environment variables | [
"samplerConfigFromEnv",
"creates",
"a",
"new",
"SamplerConfig",
"based",
"on",
"the",
"environment",
"variables"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/config/config_env.go#L96-L132 | train |
jaegertracing/jaeger-client-go | config/config_env.go | reporterConfigFromEnv | func reporterConfigFromEnv() (*ReporterConfig, error) {
rc := &ReporterConfig{}
if e := os.Getenv(envReporterMaxQueueSize); e != "" {
if value, err := strconv.ParseInt(e, 10, 0); err == nil {
rc.QueueSize = int(value)
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterMaxQueueSize, e)
}
}
if e := os.Getenv(envReporterFlushInterval); e != "" {
if value, err := time.ParseDuration(e); err == nil {
rc.BufferFlushInterval = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterFlushInterval, e)
}
}
if e := os.Getenv(envReporterLogSpans); e != "" {
if value, err := strconv.ParseBool(e); err == nil {
rc.LogSpans = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterLogSpans, e)
}
}
if e := os.Getenv(envEndpoint); e != "" {
u, err := url.ParseRequestURI(e)
if err != nil {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envEndpoint, e)
}
rc.CollectorEndpoint = u.String()
user := os.Getenv(envUser)
pswd := os.Getenv(envPassword)
if user != "" && pswd == "" || user == "" && pswd != "" {
return nil, errors.Errorf("you must set %s and %s env vars together", envUser, envPassword)
}
rc.User = user
rc.Password = pswd
} else {
host := jaeger.DefaultUDPSpanServerHost
if e := os.Getenv(envAgentHost); e != "" {
host = e
}
port := jaeger.DefaultUDPSpanServerPort
if e := os.Getenv(envAgentPort); e != "" {
if value, err := strconv.ParseInt(e, 10, 0); err == nil {
port = int(value)
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envAgentPort, e)
}
}
rc.LocalAgentHostPort = fmt.Sprintf("%s:%d", host, port)
}
return rc, nil
} | go | func reporterConfigFromEnv() (*ReporterConfig, error) {
rc := &ReporterConfig{}
if e := os.Getenv(envReporterMaxQueueSize); e != "" {
if value, err := strconv.ParseInt(e, 10, 0); err == nil {
rc.QueueSize = int(value)
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterMaxQueueSize, e)
}
}
if e := os.Getenv(envReporterFlushInterval); e != "" {
if value, err := time.ParseDuration(e); err == nil {
rc.BufferFlushInterval = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterFlushInterval, e)
}
}
if e := os.Getenv(envReporterLogSpans); e != "" {
if value, err := strconv.ParseBool(e); err == nil {
rc.LogSpans = value
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterLogSpans, e)
}
}
if e := os.Getenv(envEndpoint); e != "" {
u, err := url.ParseRequestURI(e)
if err != nil {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envEndpoint, e)
}
rc.CollectorEndpoint = u.String()
user := os.Getenv(envUser)
pswd := os.Getenv(envPassword)
if user != "" && pswd == "" || user == "" && pswd != "" {
return nil, errors.Errorf("you must set %s and %s env vars together", envUser, envPassword)
}
rc.User = user
rc.Password = pswd
} else {
host := jaeger.DefaultUDPSpanServerHost
if e := os.Getenv(envAgentHost); e != "" {
host = e
}
port := jaeger.DefaultUDPSpanServerPort
if e := os.Getenv(envAgentPort); e != "" {
if value, err := strconv.ParseInt(e, 10, 0); err == nil {
port = int(value)
} else {
return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envAgentPort, e)
}
}
rc.LocalAgentHostPort = fmt.Sprintf("%s:%d", host, port)
}
return rc, nil
} | [
"func",
"reporterConfigFromEnv",
"(",
")",
"(",
"*",
"ReporterConfig",
",",
"error",
")",
"{",
"rc",
":=",
"&",
"ReporterConfig",
"{",
"}",
"\n",
"if",
"e",
":=",
"os",
".",
"Getenv",
"(",
"envReporterMaxQueueSize",
")",
";",
"e",
"!=",
"\"\"",
"{",
"i... | // reporterConfigFromEnv creates a new ReporterConfig based on the environment variables | [
"reporterConfigFromEnv",
"creates",
"a",
"new",
"ReporterConfig",
"based",
"on",
"the",
"environment",
"variables"
] | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/config/config_env.go#L135-L193 | train |
jaegertracing/jaeger-client-go | internal/throttler/remote/options.go | SynchronousInitialization | func (options) SynchronousInitialization(b bool) Option {
return func(o *options) {
o.synchronousInitialization = b
}
} | go | func (options) SynchronousInitialization(b bool) Option {
return func(o *options) {
o.synchronousInitialization = b
}
} | [
"func",
"(",
"options",
")",
"SynchronousInitialization",
"(",
"b",
"bool",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"options",
")",
"{",
"o",
".",
"synchronousInitialization",
"=",
"b",
"\n",
"}",
"\n",
"}"
] | // SynchronousInitialization creates an Option that determines whether the throttler should synchronously
// fetch credits from the agent when an operation is seen for the first time. This should be set to true
// if the client will be used by a short lived service that needs to ensure that credits are fetched upfront
// such that sampling or throttling occurs. | [
"SynchronousInitialization",
"creates",
"an",
"Option",
"that",
"determines",
"whether",
"the",
"throttler",
"should",
"synchronously",
"fetch",
"credits",
"from",
"the",
"agent",
"when",
"an",
"operation",
"is",
"seen",
"for",
"the",
"first",
"time",
".",
"This",... | 896f2abd37e099bae3eae942250d1a37e4bdce0b | https://github.com/jaegertracing/jaeger-client-go/blob/896f2abd37e099bae3eae942250d1a37e4bdce0b/internal/throttler/remote/options.go#L75-L79 | train |
hashicorp/go-retryablehttp | client.go | BodyBytes | func (r *Request) BodyBytes() ([]byte, error) {
if r.body == nil {
return nil, nil
}
body, err := r.body()
if err != nil {
return nil, err
}
buf := new(bytes.Buffer)
_, err = buf.ReadFrom(body)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | func (r *Request) BodyBytes() ([]byte, error) {
if r.body == nil {
return nil, nil
}
body, err := r.body()
if err != nil {
return nil, err
}
buf := new(bytes.Buffer)
_, err = buf.ReadFrom(body)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | [
"func",
"(",
"r",
"*",
"Request",
")",
"BodyBytes",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"r",
".",
"body",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"body",
",",
"err",
":=",
"r",
".",
"body",
... | // BodyBytes allows accessing the request body. It is an analogue to
// http.Request's Body variable, but it returns a copy of the underlying data
// rather than consuming it.
//
// This function is not thread-safe; do not call it at the same time as another
// call, or at the same time this request is being used with Client.Do. | [
"BodyBytes",
"allows",
"accessing",
"the",
"request",
"body",
".",
"It",
"is",
"an",
"analogue",
"to",
"http",
".",
"Request",
"s",
"Body",
"variable",
"but",
"it",
"returns",
"a",
"copy",
"of",
"the",
"underlying",
"data",
"rather",
"than",
"consuming",
"... | 4ea34a9a437e0e910fe5fea5be81372a39336bb0 | https://github.com/hashicorp/go-retryablehttp/blob/4ea34a9a437e0e910fe5fea5be81372a39336bb0/client.go#L90-L104 | train |
hashicorp/go-retryablehttp | client.go | NewClient | func NewClient() *Client {
return &Client{
HTTPClient: cleanhttp.DefaultClient(),
Logger: log.New(os.Stderr, "", log.LstdFlags),
RetryWaitMin: defaultRetryWaitMin,
RetryWaitMax: defaultRetryWaitMax,
RetryMax: defaultRetryMax,
CheckRetry: DefaultRetryPolicy,
Backoff: DefaultBackoff,
}
} | go | func NewClient() *Client {
return &Client{
HTTPClient: cleanhttp.DefaultClient(),
Logger: log.New(os.Stderr, "", log.LstdFlags),
RetryWaitMin: defaultRetryWaitMin,
RetryWaitMax: defaultRetryWaitMax,
RetryMax: defaultRetryMax,
CheckRetry: DefaultRetryPolicy,
Backoff: DefaultBackoff,
}
} | [
"func",
"NewClient",
"(",
")",
"*",
"Client",
"{",
"return",
"&",
"Client",
"{",
"HTTPClient",
":",
"cleanhttp",
".",
"DefaultClient",
"(",
")",
",",
"Logger",
":",
"log",
".",
"New",
"(",
"os",
".",
"Stderr",
",",
"\"\"",
",",
"log",
".",
"LstdFlags... | // NewClient creates a new Client with default settings. | [
"NewClient",
"creates",
"a",
"new",
"Client",
"with",
"default",
"settings",
"."
] | 4ea34a9a437e0e910fe5fea5be81372a39336bb0 | https://github.com/hashicorp/go-retryablehttp/blob/4ea34a9a437e0e910fe5fea5be81372a39336bb0/client.go#L278-L288 | train |
hashicorp/go-retryablehttp | client.go | DefaultRetryPolicy | func DefaultRetryPolicy(ctx context.Context, resp *http.Response, err error) (bool, error) {
// do not retry on context.Canceled or context.DeadlineExceeded
if ctx.Err() != nil {
return false, ctx.Err()
}
if err != nil {
return true, err
}
// Check the response code. We retry on 500-range responses to allow
// the server time to recover, as 500's are typically not permanent
// errors and may relate to outages on the server side. This will catch
// invalid response codes as well, like 0 and 999.
if resp.StatusCode == 0 || (resp.StatusCode >= 500 && resp.StatusCode != 501) {
return true, nil
}
return false, nil
} | go | func DefaultRetryPolicy(ctx context.Context, resp *http.Response, err error) (bool, error) {
// do not retry on context.Canceled or context.DeadlineExceeded
if ctx.Err() != nil {
return false, ctx.Err()
}
if err != nil {
return true, err
}
// Check the response code. We retry on 500-range responses to allow
// the server time to recover, as 500's are typically not permanent
// errors and may relate to outages on the server side. This will catch
// invalid response codes as well, like 0 and 999.
if resp.StatusCode == 0 || (resp.StatusCode >= 500 && resp.StatusCode != 501) {
return true, nil
}
return false, nil
} | [
"func",
"DefaultRetryPolicy",
"(",
"ctx",
"context",
".",
"Context",
",",
"resp",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"ctx",
".",
"Err",
"(",
")",
"!=",
"nil",
"{",
"return",
"false",
"... | // DefaultRetryPolicy provides a default callback for Client.CheckRetry, which
// will retry on connection errors and server errors. | [
"DefaultRetryPolicy",
"provides",
"a",
"default",
"callback",
"for",
"Client",
".",
"CheckRetry",
"which",
"will",
"retry",
"on",
"connection",
"errors",
"and",
"server",
"errors",
"."
] | 4ea34a9a437e0e910fe5fea5be81372a39336bb0 | https://github.com/hashicorp/go-retryablehttp/blob/4ea34a9a437e0e910fe5fea5be81372a39336bb0/client.go#L292-L310 | train |
hashicorp/go-retryablehttp | client.go | DefaultBackoff | func DefaultBackoff(min, max time.Duration, attemptNum int, resp *http.Response) time.Duration {
mult := math.Pow(2, float64(attemptNum)) * float64(min)
sleep := time.Duration(mult)
if float64(sleep) != mult || sleep > max {
sleep = max
}
return sleep
} | go | func DefaultBackoff(min, max time.Duration, attemptNum int, resp *http.Response) time.Duration {
mult := math.Pow(2, float64(attemptNum)) * float64(min)
sleep := time.Duration(mult)
if float64(sleep) != mult || sleep > max {
sleep = max
}
return sleep
} | [
"func",
"DefaultBackoff",
"(",
"min",
",",
"max",
"time",
".",
"Duration",
",",
"attemptNum",
"int",
",",
"resp",
"*",
"http",
".",
"Response",
")",
"time",
".",
"Duration",
"{",
"mult",
":=",
"math",
".",
"Pow",
"(",
"2",
",",
"float64",
"(",
"attem... | // DefaultBackoff provides a default callback for Client.Backoff which
// will perform exponential backoff based on the attempt number and limited
// by the provided minimum and maximum durations. | [
"DefaultBackoff",
"provides",
"a",
"default",
"callback",
"for",
"Client",
".",
"Backoff",
"which",
"will",
"perform",
"exponential",
"backoff",
"based",
"on",
"the",
"attempt",
"number",
"and",
"limited",
"by",
"the",
"provided",
"minimum",
"and",
"maximum",
"d... | 4ea34a9a437e0e910fe5fea5be81372a39336bb0 | https://github.com/hashicorp/go-retryablehttp/blob/4ea34a9a437e0e910fe5fea5be81372a39336bb0/client.go#L315-L322 | train |
hashicorp/go-retryablehttp | client.go | Do | func (c *Client) Do(req *Request) (*http.Response, error) {
if c.Logger != nil {
c.Logger.Printf("[DEBUG] %s %s", req.Method, req.URL)
}
var resp *http.Response
var err error
for i := 0; ; i++ {
var code int // HTTP response code
// Always rewind the request body when non-nil.
if req.body != nil {
body, err := req.body()
if err != nil {
return resp, err
}
if c, ok := body.(io.ReadCloser); ok {
req.Body = c
} else {
req.Body = ioutil.NopCloser(body)
}
}
if c.RequestLogHook != nil {
c.RequestLogHook(c.Logger, req.Request, i)
}
// Attempt the request
resp, err = c.HTTPClient.Do(req.Request)
if resp != nil {
code = resp.StatusCode
}
// Check if we should continue with retries.
checkOK, checkErr := c.CheckRetry(req.Context(), resp, err)
if err != nil {
if c.Logger != nil {
c.Logger.Printf("[ERR] %s %s request failed: %v", req.Method, req.URL, err)
}
} else {
// Call this here to maintain the behavior of logging all requests,
// even if CheckRetry signals to stop.
if c.ResponseLogHook != nil {
// Call the response logger function if provided.
c.ResponseLogHook(c.Logger, resp)
}
}
// Now decide if we should continue.
if !checkOK {
if checkErr != nil {
err = checkErr
}
return resp, err
}
// We do this before drainBody beause there's no need for the I/O if
// we're breaking out
remain := c.RetryMax - i
if remain <= 0 {
break
}
// We're going to retry, consume any response to reuse the connection.
if err == nil && resp != nil {
c.drainBody(resp.Body)
}
wait := c.Backoff(c.RetryWaitMin, c.RetryWaitMax, i, resp)
desc := fmt.Sprintf("%s %s", req.Method, req.URL)
if code > 0 {
desc = fmt.Sprintf("%s (status: %d)", desc, code)
}
if c.Logger != nil {
c.Logger.Printf("[DEBUG] %s: retrying in %s (%d left)", desc, wait, remain)
}
select {
case <-req.Context().Done():
return nil, req.Context().Err()
case <-time.After(wait):
}
}
if c.ErrorHandler != nil {
return c.ErrorHandler(resp, err, c.RetryMax+1)
}
// By default, we close the response body and return an error without
// returning the response
if resp != nil {
resp.Body.Close()
}
return nil, fmt.Errorf("%s %s giving up after %d attempts",
req.Method, req.URL, c.RetryMax+1)
} | go | func (c *Client) Do(req *Request) (*http.Response, error) {
if c.Logger != nil {
c.Logger.Printf("[DEBUG] %s %s", req.Method, req.URL)
}
var resp *http.Response
var err error
for i := 0; ; i++ {
var code int // HTTP response code
// Always rewind the request body when non-nil.
if req.body != nil {
body, err := req.body()
if err != nil {
return resp, err
}
if c, ok := body.(io.ReadCloser); ok {
req.Body = c
} else {
req.Body = ioutil.NopCloser(body)
}
}
if c.RequestLogHook != nil {
c.RequestLogHook(c.Logger, req.Request, i)
}
// Attempt the request
resp, err = c.HTTPClient.Do(req.Request)
if resp != nil {
code = resp.StatusCode
}
// Check if we should continue with retries.
checkOK, checkErr := c.CheckRetry(req.Context(), resp, err)
if err != nil {
if c.Logger != nil {
c.Logger.Printf("[ERR] %s %s request failed: %v", req.Method, req.URL, err)
}
} else {
// Call this here to maintain the behavior of logging all requests,
// even if CheckRetry signals to stop.
if c.ResponseLogHook != nil {
// Call the response logger function if provided.
c.ResponseLogHook(c.Logger, resp)
}
}
// Now decide if we should continue.
if !checkOK {
if checkErr != nil {
err = checkErr
}
return resp, err
}
// We do this before drainBody beause there's no need for the I/O if
// we're breaking out
remain := c.RetryMax - i
if remain <= 0 {
break
}
// We're going to retry, consume any response to reuse the connection.
if err == nil && resp != nil {
c.drainBody(resp.Body)
}
wait := c.Backoff(c.RetryWaitMin, c.RetryWaitMax, i, resp)
desc := fmt.Sprintf("%s %s", req.Method, req.URL)
if code > 0 {
desc = fmt.Sprintf("%s (status: %d)", desc, code)
}
if c.Logger != nil {
c.Logger.Printf("[DEBUG] %s: retrying in %s (%d left)", desc, wait, remain)
}
select {
case <-req.Context().Done():
return nil, req.Context().Err()
case <-time.After(wait):
}
}
if c.ErrorHandler != nil {
return c.ErrorHandler(resp, err, c.RetryMax+1)
}
// By default, we close the response body and return an error without
// returning the response
if resp != nil {
resp.Body.Close()
}
return nil, fmt.Errorf("%s %s giving up after %d attempts",
req.Method, req.URL, c.RetryMax+1)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Do",
"(",
"req",
"*",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"if",
"c",
".",
"Logger",
"!=",
"nil",
"{",
"c",
".",
"Logger",
".",
"Printf",
"(",
"\"[DEBUG] %s %s\"",
",",
... | // Do wraps calling an HTTP method with retries. | [
"Do",
"wraps",
"calling",
"an",
"HTTP",
"method",
"with",
"retries",
"."
] | 4ea34a9a437e0e910fe5fea5be81372a39336bb0 | https://github.com/hashicorp/go-retryablehttp/blob/4ea34a9a437e0e910fe5fea5be81372a39336bb0/client.go#L370-L466 | train |
hashicorp/go-retryablehttp | client.go | drainBody | func (c *Client) drainBody(body io.ReadCloser) {
defer body.Close()
_, err := io.Copy(ioutil.Discard, io.LimitReader(body, respReadLimit))
if err != nil {
if c.Logger != nil {
c.Logger.Printf("[ERR] error reading response body: %v", err)
}
}
} | go | func (c *Client) drainBody(body io.ReadCloser) {
defer body.Close()
_, err := io.Copy(ioutil.Discard, io.LimitReader(body, respReadLimit))
if err != nil {
if c.Logger != nil {
c.Logger.Printf("[ERR] error reading response body: %v", err)
}
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"drainBody",
"(",
"body",
"io",
".",
"ReadCloser",
")",
"{",
"defer",
"body",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"ioutil",
".",
"Discard",
",",
"io",
".",
"LimitReade... | // Try to read the response body so we can reuse this connection. | [
"Try",
"to",
"read",
"the",
"response",
"body",
"so",
"we",
"can",
"reuse",
"this",
"connection",
"."
] | 4ea34a9a437e0e910fe5fea5be81372a39336bb0 | https://github.com/hashicorp/go-retryablehttp/blob/4ea34a9a437e0e910fe5fea5be81372a39336bb0/client.go#L469-L477 | train |
hashicorp/go-retryablehttp | client.go | Post | func Post(url, bodyType string, body interface{}) (*http.Response, error) {
return defaultClient.Post(url, bodyType, body)
} | go | func Post(url, bodyType string, body interface{}) (*http.Response, error) {
return defaultClient.Post(url, bodyType, body)
} | [
"func",
"Post",
"(",
"url",
",",
"bodyType",
"string",
",",
"body",
"interface",
"{",
"}",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"defaultClient",
".",
"Post",
"(",
"url",
",",
"bodyType",
",",
"body",
")",
"\n",
... | // Post is a shortcut for doing a POST request without making a new client. | [
"Post",
"is",
"a",
"shortcut",
"for",
"doing",
"a",
"POST",
"request",
"without",
"making",
"a",
"new",
"client",
"."
] | 4ea34a9a437e0e910fe5fea5be81372a39336bb0 | https://github.com/hashicorp/go-retryablehttp/blob/4ea34a9a437e0e910fe5fea5be81372a39336bb0/client.go#L508-L510 | train |
hashicorp/go-retryablehttp | client.go | PostForm | func PostForm(url string, data url.Values) (*http.Response, error) {
return defaultClient.PostForm(url, data)
} | go | func PostForm(url string, data url.Values) (*http.Response, error) {
return defaultClient.PostForm(url, data)
} | [
"func",
"PostForm",
"(",
"url",
"string",
",",
"data",
"url",
".",
"Values",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"defaultClient",
".",
"PostForm",
"(",
"url",
",",
"data",
")",
"\n",
"}"
] | // PostForm is a shortcut to perform a POST with form data without creating
// a new client. | [
"PostForm",
"is",
"a",
"shortcut",
"to",
"perform",
"a",
"POST",
"with",
"form",
"data",
"without",
"creating",
"a",
"new",
"client",
"."
] | 4ea34a9a437e0e910fe5fea5be81372a39336bb0 | https://github.com/hashicorp/go-retryablehttp/blob/4ea34a9a437e0e910fe5fea5be81372a39336bb0/client.go#L524-L526 | train |
jolestar/go-commons-pool | concurrent/atomic.go | GetAndIncrement | func (i *AtomicInteger) GetAndIncrement() int32 {
ret := atomic.LoadInt32((*int32)(i))
atomic.AddInt32((*int32)(i), int32(1))
return ret
} | go | func (i *AtomicInteger) GetAndIncrement() int32 {
ret := atomic.LoadInt32((*int32)(i))
atomic.AddInt32((*int32)(i), int32(1))
return ret
} | [
"func",
"(",
"i",
"*",
"AtomicInteger",
")",
"GetAndIncrement",
"(",
")",
"int32",
"{",
"ret",
":=",
"atomic",
".",
"LoadInt32",
"(",
"(",
"*",
"int32",
")",
"(",
"i",
")",
")",
"\n",
"atomic",
".",
"AddInt32",
"(",
"(",
"*",
"int32",
")",
"(",
"... | // GetAndIncrement increment wrapped int32 with 1 and return old value. | [
"GetAndIncrement",
"increment",
"wrapped",
"int32",
"with",
"1",
"and",
"return",
"old",
"value",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/concurrent/atomic.go#L14-L18 | train |
jolestar/go-commons-pool | concurrent/atomic.go | GetAndDecrement | func (i *AtomicInteger) GetAndDecrement() int32 {
ret := atomic.LoadInt32((*int32)(i))
atomic.AddInt32((*int32)(i), int32(-1))
return ret
} | go | func (i *AtomicInteger) GetAndDecrement() int32 {
ret := atomic.LoadInt32((*int32)(i))
atomic.AddInt32((*int32)(i), int32(-1))
return ret
} | [
"func",
"(",
"i",
"*",
"AtomicInteger",
")",
"GetAndDecrement",
"(",
")",
"int32",
"{",
"ret",
":=",
"atomic",
".",
"LoadInt32",
"(",
"(",
"*",
"int32",
")",
"(",
"i",
")",
")",
"\n",
"atomic",
".",
"AddInt32",
"(",
"(",
"*",
"int32",
")",
"(",
"... | // GetAndDecrement decrement wrapped int32 with 1 and return old value. | [
"GetAndDecrement",
"decrement",
"wrapped",
"int32",
"with",
"1",
"and",
"return",
"old",
"value",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/concurrent/atomic.go#L26-L30 | train |
jolestar/go-commons-pool | concurrent/cond.go | NewTimeoutCond | func NewTimeoutCond(l sync.Locker) *TimeoutCond {
cond := TimeoutCond{L: l, signal: make(chan int, 0)}
return &cond
} | go | func NewTimeoutCond(l sync.Locker) *TimeoutCond {
cond := TimeoutCond{L: l, signal: make(chan int, 0)}
return &cond
} | [
"func",
"NewTimeoutCond",
"(",
"l",
"sync",
".",
"Locker",
")",
"*",
"TimeoutCond",
"{",
"cond",
":=",
"TimeoutCond",
"{",
"L",
":",
"l",
",",
"signal",
":",
"make",
"(",
"chan",
"int",
",",
"0",
")",
"}",
"\n",
"return",
"&",
"cond",
"\n",
"}"
] | // NewTimeoutCond return a new TimeoutCond | [
"NewTimeoutCond",
"return",
"a",
"new",
"TimeoutCond"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/concurrent/cond.go#L19-L22 | train |
jolestar/go-commons-pool | concurrent/cond.go | Wait | func (cond *TimeoutCond) Wait(ctx context.Context) bool {
cond.addWaiter()
//copy signal in lock, avoid data race with Interrupt
ch := cond.signal
//wait should unlock mutex, if not will cause deadlock
cond.L.Unlock()
defer cond.removeWaiter()
defer cond.L.Lock()
select {
case _, ok := <-ch:
return !ok
case <-ctx.Done():
return false
}
} | go | func (cond *TimeoutCond) Wait(ctx context.Context) bool {
cond.addWaiter()
//copy signal in lock, avoid data race with Interrupt
ch := cond.signal
//wait should unlock mutex, if not will cause deadlock
cond.L.Unlock()
defer cond.removeWaiter()
defer cond.L.Lock()
select {
case _, ok := <-ch:
return !ok
case <-ctx.Done():
return false
}
} | [
"func",
"(",
"cond",
"*",
"TimeoutCond",
")",
"Wait",
"(",
"ctx",
"context",
".",
"Context",
")",
"bool",
"{",
"cond",
".",
"addWaiter",
"(",
")",
"\n",
"ch",
":=",
"cond",
".",
"signal",
"\n",
"cond",
".",
"L",
".",
"Unlock",
"(",
")",
"\n",
"de... | // Wait waits for a signal, or for the context do be done. Returns true if signaled. | [
"Wait",
"waits",
"for",
"a",
"signal",
"or",
"for",
"the",
"context",
"do",
"be",
"done",
".",
"Returns",
"true",
"if",
"signaled",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/concurrent/cond.go#L46-L61 | train |
jolestar/go-commons-pool | concurrent/cond.go | Interrupt | func (cond *TimeoutCond) Interrupt() {
cond.L.Lock()
defer cond.L.Unlock()
close(cond.signal)
cond.signal = make(chan int, 0)
} | go | func (cond *TimeoutCond) Interrupt() {
cond.L.Lock()
defer cond.L.Unlock()
close(cond.signal)
cond.signal = make(chan int, 0)
} | [
"func",
"(",
"cond",
"*",
"TimeoutCond",
")",
"Interrupt",
"(",
")",
"{",
"cond",
".",
"L",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cond",
".",
"L",
".",
"Unlock",
"(",
")",
"\n",
"close",
"(",
"cond",
".",
"signal",
")",
"\n",
"cond",
".",
"sig... | // Interrupt goroutine wait on this TimeoutCond | [
"Interrupt",
"goroutine",
"wait",
"on",
"this",
"TimeoutCond"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/concurrent/cond.go#L72-L77 | train |
jolestar/go-commons-pool | pool.go | NewObjectPool | func NewObjectPool(ctx context.Context, factory PooledObjectFactory, config *ObjectPoolConfig) *ObjectPool {
return NewObjectPoolWithAbandonedConfig(ctx, factory, config, nil)
} | go | func NewObjectPool(ctx context.Context, factory PooledObjectFactory, config *ObjectPoolConfig) *ObjectPool {
return NewObjectPoolWithAbandonedConfig(ctx, factory, config, nil)
} | [
"func",
"NewObjectPool",
"(",
"ctx",
"context",
".",
"Context",
",",
"factory",
"PooledObjectFactory",
",",
"config",
"*",
"ObjectPoolConfig",
")",
"*",
"ObjectPool",
"{",
"return",
"NewObjectPoolWithAbandonedConfig",
"(",
"ctx",
",",
"factory",
",",
"config",
","... | // NewObjectPool return new ObjectPool, init with PooledObjectFactory and ObjectPoolConfig | [
"NewObjectPool",
"return",
"new",
"ObjectPool",
"init",
"with",
"PooledObjectFactory",
"and",
"ObjectPoolConfig"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/pool.go#L63-L65 | train |
jolestar/go-commons-pool | pool.go | NewObjectPoolWithDefaultConfig | func NewObjectPoolWithDefaultConfig(ctx context.Context, factory PooledObjectFactory) *ObjectPool {
return NewObjectPool(ctx, factory, NewDefaultPoolConfig())
} | go | func NewObjectPoolWithDefaultConfig(ctx context.Context, factory PooledObjectFactory) *ObjectPool {
return NewObjectPool(ctx, factory, NewDefaultPoolConfig())
} | [
"func",
"NewObjectPoolWithDefaultConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"factory",
"PooledObjectFactory",
")",
"*",
"ObjectPool",
"{",
"return",
"NewObjectPool",
"(",
"ctx",
",",
"factory",
",",
"NewDefaultPoolConfig",
"(",
")",
")",
"\n",
"}"
] | // NewObjectPoolWithDefaultConfig return new ObjectPool init with PooledObjectFactory and default config | [
"NewObjectPoolWithDefaultConfig",
"return",
"new",
"ObjectPool",
"init",
"with",
"PooledObjectFactory",
"and",
"default",
"config"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/pool.go#L68-L70 | train |
jolestar/go-commons-pool | pool.go | NewObjectPoolWithAbandonedConfig | func NewObjectPoolWithAbandonedConfig(ctx context.Context, factory PooledObjectFactory, config *ObjectPoolConfig, abandonedConfig *AbandonedConfig) *ObjectPool {
pool := ObjectPool{factory: factory, Config: config,
idleObjects: collections.NewDeque(math.MaxInt32),
allObjects: collections.NewSyncMap(),
createCount: concurrent.AtomicInteger(0),
destroyedByEvictorCount: concurrent.AtomicInteger(0),
destroyedCount: concurrent.AtomicInteger(0),
AbandonedConfig: abandonedConfig}
pool.StartEvictor()
return &pool
} | go | func NewObjectPoolWithAbandonedConfig(ctx context.Context, factory PooledObjectFactory, config *ObjectPoolConfig, abandonedConfig *AbandonedConfig) *ObjectPool {
pool := ObjectPool{factory: factory, Config: config,
idleObjects: collections.NewDeque(math.MaxInt32),
allObjects: collections.NewSyncMap(),
createCount: concurrent.AtomicInteger(0),
destroyedByEvictorCount: concurrent.AtomicInteger(0),
destroyedCount: concurrent.AtomicInteger(0),
AbandonedConfig: abandonedConfig}
pool.StartEvictor()
return &pool
} | [
"func",
"NewObjectPoolWithAbandonedConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"factory",
"PooledObjectFactory",
",",
"config",
"*",
"ObjectPoolConfig",
",",
"abandonedConfig",
"*",
"AbandonedConfig",
")",
"*",
"ObjectPool",
"{",
"pool",
":=",
"ObjectPool",
... | // NewObjectPoolWithAbandonedConfig return new ObjectPool init with PooledObjectFactory, ObjectPoolConfig, and AbandonedConfig | [
"NewObjectPoolWithAbandonedConfig",
"return",
"new",
"ObjectPool",
"init",
"with",
"PooledObjectFactory",
"ObjectPoolConfig",
"and",
"AbandonedConfig"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/pool.go#L73-L83 | train |
jolestar/go-commons-pool | pool.go | GetNumActive | func (pool *ObjectPool) GetNumActive() int {
return pool.allObjects.Size() - pool.idleObjects.Size()
} | go | func (pool *ObjectPool) GetNumActive() int {
return pool.allObjects.Size() - pool.idleObjects.Size()
} | [
"func",
"(",
"pool",
"*",
"ObjectPool",
")",
"GetNumActive",
"(",
")",
"int",
"{",
"return",
"pool",
".",
"allObjects",
".",
"Size",
"(",
")",
"-",
"pool",
".",
"idleObjects",
".",
"Size",
"(",
")",
"\n",
"}"
] | // GetNumActive return the number of instances currently borrowed from pool. | [
"GetNumActive",
"return",
"the",
"number",
"of",
"instances",
"currently",
"borrowed",
"from",
"pool",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/pool.go#L152-L154 | train |
jolestar/go-commons-pool | pool.go | IsClosed | func (pool *ObjectPool) IsClosed() bool {
pool.closeLock.Lock()
defer pool.closeLock.Unlock()
// in java commons pool, closed is volatile, golang has not volatile, so use mutex to avoid data race
return pool.closed
} | go | func (pool *ObjectPool) IsClosed() bool {
pool.closeLock.Lock()
defer pool.closeLock.Unlock()
// in java commons pool, closed is volatile, golang has not volatile, so use mutex to avoid data race
return pool.closed
} | [
"func",
"(",
"pool",
"*",
"ObjectPool",
")",
"IsClosed",
"(",
")",
"bool",
"{",
"pool",
".",
"closeLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pool",
".",
"closeLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"pool",
".",
"closed",
"\n",
"}"
] | // IsClosed return this pool is closed | [
"IsClosed",
"return",
"this",
"pool",
"is",
"closed"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/pool.go#L366-L371 | train |
jolestar/go-commons-pool | pool.go | Close | func (pool *ObjectPool) Close(ctx context.Context) {
if pool.IsClosed() {
return
}
pool.closeLock.Lock()
defer pool.closeLock.Unlock()
if pool.closed {
return
}
// Stop the evictor before the pool is closed since evict() calls
// assertOpen()
pool.startEvictor(-1)
pool.closed = true
// This clear removes any idle objects
pool.Clear(ctx)
// Release any goroutines that were waiting for an object
pool.idleObjects.InterruptTakeWaiters()
} | go | func (pool *ObjectPool) Close(ctx context.Context) {
if pool.IsClosed() {
return
}
pool.closeLock.Lock()
defer pool.closeLock.Unlock()
if pool.closed {
return
}
// Stop the evictor before the pool is closed since evict() calls
// assertOpen()
pool.startEvictor(-1)
pool.closed = true
// This clear removes any idle objects
pool.Clear(ctx)
// Release any goroutines that were waiting for an object
pool.idleObjects.InterruptTakeWaiters()
} | [
"func",
"(",
"pool",
"*",
"ObjectPool",
")",
"Close",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"if",
"pool",
".",
"IsClosed",
"(",
")",
"{",
"return",
"\n",
"}",
"\n",
"pool",
".",
"closeLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pool",
... | // Close pool, and free any resources associated with it. | [
"Close",
"pool",
"and",
"free",
"any",
"resources",
"associated",
"with",
"it",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/pool.go#L482-L502 | train |
jolestar/go-commons-pool | pool.go | idleIterator | func (pool *ObjectPool) idleIterator() collections.Iterator {
if pool.Config.LIFO {
return pool.idleObjects.DescendingIterator()
}
return pool.idleObjects.Iterator()
} | go | func (pool *ObjectPool) idleIterator() collections.Iterator {
if pool.Config.LIFO {
return pool.idleObjects.DescendingIterator()
}
return pool.idleObjects.Iterator()
} | [
"func",
"(",
"pool",
"*",
"ObjectPool",
")",
"idleIterator",
"(",
")",
"collections",
".",
"Iterator",
"{",
"if",
"pool",
".",
"Config",
".",
"LIFO",
"{",
"return",
"pool",
".",
"idleObjects",
".",
"DescendingIterator",
"(",
")",
"\n",
"}",
"\n",
"return... | // idleIterator return pool idleObjects iterator | [
"idleIterator",
"return",
"pool",
"idleObjects",
"iterator"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/pool.go#L561-L566 | train |
jolestar/go-commons-pool | pool.go | Prefill | func Prefill(ctx context.Context, pool *ObjectPool, count int) {
for i := 0; i < count; i++ {
pool.AddObject(ctx)
}
} | go | func Prefill(ctx context.Context, pool *ObjectPool, count int) {
for i := 0; i < count; i++ {
pool.AddObject(ctx)
}
} | [
"func",
"Prefill",
"(",
"ctx",
"context",
".",
"Context",
",",
"pool",
"*",
"ObjectPool",
",",
"count",
"int",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"++",
"{",
"pool",
".",
"AddObject",
"(",
"ctx",
")",
"\n",
"}",
"... | // Prefill is util func for pre fill pool object | [
"Prefill",
"is",
"util",
"func",
"for",
"pre",
"fill",
"pool",
"object"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/pool.go#L676-L680 | train |
jolestar/go-commons-pool | collections/collections.go | Get | func (m *SyncIdentityMap) Get(key interface{}) interface{} {
m.RLock()
keyPtr := genKey(key)
value := m.m[keyPtr]
m.RUnlock()
return value
} | go | func (m *SyncIdentityMap) Get(key interface{}) interface{} {
m.RLock()
keyPtr := genKey(key)
value := m.m[keyPtr]
m.RUnlock()
return value
} | [
"func",
"(",
"m",
"*",
"SyncIdentityMap",
")",
"Get",
"(",
"key",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"m",
".",
"RLock",
"(",
")",
"\n",
"keyPtr",
":=",
"genKey",
"(",
"key",
")",
"\n",
"value",
":=",
"m",
".",
"m",
"[",
"ke... | // Get by key | [
"Get",
"by",
"key"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/collections.go#L29-L35 | train |
jolestar/go-commons-pool | collections/collections.go | Put | func (m *SyncIdentityMap) Put(key interface{}, value interface{}) {
m.Lock()
keyPtr := genKey(key)
m.m[keyPtr] = value
m.Unlock()
} | go | func (m *SyncIdentityMap) Put(key interface{}, value interface{}) {
m.Lock()
keyPtr := genKey(key)
m.m[keyPtr] = value
m.Unlock()
} | [
"func",
"(",
"m",
"*",
"SyncIdentityMap",
")",
"Put",
"(",
"key",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"keyPtr",
":=",
"genKey",
"(",
"key",
")",
"\n",
"m",
".",
"m",
"[",
"keyP... | // Put key and value to map | [
"Put",
"key",
"and",
"value",
"to",
"map"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/collections.go#L43-L48 | train |
jolestar/go-commons-pool | collections/collections.go | Remove | func (m *SyncIdentityMap) Remove(key interface{}) {
m.Lock()
keyPtr := genKey(key)
delete(m.m, keyPtr)
m.Unlock()
} | go | func (m *SyncIdentityMap) Remove(key interface{}) {
m.Lock()
keyPtr := genKey(key)
delete(m.m, keyPtr)
m.Unlock()
} | [
"func",
"(",
"m",
"*",
"SyncIdentityMap",
")",
"Remove",
"(",
"key",
"interface",
"{",
"}",
")",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"keyPtr",
":=",
"genKey",
"(",
"key",
")",
"\n",
"delete",
"(",
"m",
".",
"m",
",",
"keyPtr",
")",
"\n",
"m"... | // Remove value by key | [
"Remove",
"value",
"by",
"key"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/collections.go#L51-L56 | train |
jolestar/go-commons-pool | collections/collections.go | Size | func (m *SyncIdentityMap) Size() int {
m.RLock()
defer m.RUnlock()
return len(m.m)
} | go | func (m *SyncIdentityMap) Size() int {
m.RLock()
defer m.RUnlock()
return len(m.m)
} | [
"func",
"(",
"m",
"*",
"SyncIdentityMap",
")",
"Size",
"(",
")",
"int",
"{",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"len",
"(",
"m",
".",
"m",
")",
"\n",
"}"
] | // Size return map len, and is concurrent safe | [
"Size",
"return",
"map",
"len",
"and",
"is",
"concurrent",
"safe"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/collections.go#L59-L63 | train |
jolestar/go-commons-pool | collections/collections.go | Values | func (m *SyncIdentityMap) Values() []interface{} {
m.RLock()
defer m.RUnlock()
list := make([]interface{}, len(m.m))
i := 0
for _, v := range m.m {
list[i] = v
i++
}
return list
} | go | func (m *SyncIdentityMap) Values() []interface{} {
m.RLock()
defer m.RUnlock()
list := make([]interface{}, len(m.m))
i := 0
for _, v := range m.m {
list[i] = v
i++
}
return list
} | [
"func",
"(",
"m",
"*",
"SyncIdentityMap",
")",
"Values",
"(",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"RUnlock",
"(",
")",
"\n",
"list",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}"... | // Values copy all map's value to slice | [
"Values",
"copy",
"all",
"map",
"s",
"value",
"to",
"slice"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/collections.go#L66-L76 | train |
jolestar/go-commons-pool | object.go | NewPooledObject | func NewPooledObject(object interface{}) *PooledObject {
time := time.Now()
return &PooledObject{Object: object, state: StateIdle, CreateTime: time, LastUseTime: time, LastBorrowTime: time, LastReturnTime: time}
} | go | func NewPooledObject(object interface{}) *PooledObject {
time := time.Now()
return &PooledObject{Object: object, state: StateIdle, CreateTime: time, LastUseTime: time, LastBorrowTime: time, LastReturnTime: time}
} | [
"func",
"NewPooledObject",
"(",
"object",
"interface",
"{",
"}",
")",
"*",
"PooledObject",
"{",
"time",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"return",
"&",
"PooledObject",
"{",
"Object",
":",
"object",
",",
"state",
":",
"StateIdle",
",",
"CreateTim... | // NewPooledObject return new init PooledObject | [
"NewPooledObject",
"return",
"new",
"init",
"PooledObject"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L61-L64 | train |
jolestar/go-commons-pool | object.go | GetActiveTime | func (o *PooledObject) GetActiveTime() time.Duration {
// Take copies to avoid concurrent issues
rTime := o.LastReturnTime
bTime := o.LastBorrowTime
if rTime.After(bTime) {
return rTime.Sub(bTime)
}
return time.Since(bTime)
} | go | func (o *PooledObject) GetActiveTime() time.Duration {
// Take copies to avoid concurrent issues
rTime := o.LastReturnTime
bTime := o.LastBorrowTime
if rTime.After(bTime) {
return rTime.Sub(bTime)
}
return time.Since(bTime)
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"GetActiveTime",
"(",
")",
"time",
".",
"Duration",
"{",
"rTime",
":=",
"o",
".",
"LastReturnTime",
"\n",
"bTime",
":=",
"o",
".",
"LastBorrowTime",
"\n",
"if",
"rTime",
".",
"After",
"(",
"bTime",
")",
"{",
... | // GetActiveTime return the time that this object last spent in the the active state | [
"GetActiveTime",
"return",
"the",
"time",
"that",
"this",
"object",
"last",
"spent",
"in",
"the",
"the",
"active",
"state"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L67-L76 | train |
jolestar/go-commons-pool | object.go | GetIdleTime | func (o *PooledObject) GetIdleTime() time.Duration {
elapsed := time.Since(o.LastReturnTime)
// elapsed may be negative if:
// - another goroutine updates lastReturnTime during the calculation window
if elapsed >= 0 {
return elapsed
}
return 0
} | go | func (o *PooledObject) GetIdleTime() time.Duration {
elapsed := time.Since(o.LastReturnTime)
// elapsed may be negative if:
// - another goroutine updates lastReturnTime during the calculation window
if elapsed >= 0 {
return elapsed
}
return 0
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"GetIdleTime",
"(",
")",
"time",
".",
"Duration",
"{",
"elapsed",
":=",
"time",
".",
"Since",
"(",
"o",
".",
"LastReturnTime",
")",
"\n",
"if",
"elapsed",
">=",
"0",
"{",
"return",
"elapsed",
"\n",
"}",
"\n... | // GetIdleTime the time that this object last spend in the the idle state | [
"GetIdleTime",
"the",
"time",
"that",
"this",
"object",
"last",
"spend",
"in",
"the",
"the",
"idle",
"state"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L79-L87 | train |
jolestar/go-commons-pool | object.go | GetLastUsedTime | func (o *PooledObject) GetLastUsedTime() time.Time {
trackedUse, ok := o.Object.(TrackedUse)
if ok && trackedUse.GetLastUsed().After(o.LastUseTime) {
return trackedUse.GetLastUsed()
}
return o.LastUseTime
} | go | func (o *PooledObject) GetLastUsedTime() time.Time {
trackedUse, ok := o.Object.(TrackedUse)
if ok && trackedUse.GetLastUsed().After(o.LastUseTime) {
return trackedUse.GetLastUsed()
}
return o.LastUseTime
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"GetLastUsedTime",
"(",
")",
"time",
".",
"Time",
"{",
"trackedUse",
",",
"ok",
":=",
"o",
".",
"Object",
".",
"(",
"TrackedUse",
")",
"\n",
"if",
"ok",
"&&",
"trackedUse",
".",
"GetLastUsed",
"(",
")",
"."... | // GetLastUsedTime return an estimate of the last time this object was used. | [
"GetLastUsedTime",
"return",
"an",
"estimate",
"of",
"the",
"last",
"time",
"this",
"object",
"was",
"used",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L90-L96 | train |
jolestar/go-commons-pool | object.go | Allocate | func (o *PooledObject) Allocate() bool {
o.lock.Lock()
result := o.doAllocate()
o.lock.Unlock()
return result
} | go | func (o *PooledObject) Allocate() bool {
o.lock.Lock()
result := o.doAllocate()
o.lock.Unlock()
return result
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"Allocate",
"(",
")",
"bool",
"{",
"o",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"result",
":=",
"o",
".",
"doAllocate",
"(",
")",
"\n",
"o",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"re... | // Allocate this object | [
"Allocate",
"this",
"object"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L119-L124 | train |
jolestar/go-commons-pool | object.go | Deallocate | func (o *PooledObject) Deallocate() bool {
o.lock.Lock()
result := o.doDeallocate()
o.lock.Unlock()
return result
} | go | func (o *PooledObject) Deallocate() bool {
o.lock.Lock()
result := o.doDeallocate()
o.lock.Unlock()
return result
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"Deallocate",
"(",
")",
"bool",
"{",
"o",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"result",
":=",
"o",
".",
"doDeallocate",
"(",
")",
"\n",
"o",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
... | // Deallocate this object | [
"Deallocate",
"this",
"object"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L138-L143 | train |
jolestar/go-commons-pool | object.go | Invalidate | func (o *PooledObject) Invalidate() {
o.lock.Lock()
o.invalidate()
o.lock.Unlock()
} | go | func (o *PooledObject) Invalidate() {
o.lock.Lock()
o.invalidate()
o.lock.Unlock()
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"Invalidate",
"(",
")",
"{",
"o",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"o",
".",
"invalidate",
"(",
")",
"\n",
"o",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // Invalidate this object | [
"Invalidate",
"this",
"object"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L146-L150 | train |
jolestar/go-commons-pool | object.go | GetState | func (o *PooledObject) GetState() PooledObjectState {
o.lock.Lock()
defer o.lock.Unlock()
return o.state
} | go | func (o *PooledObject) GetState() PooledObjectState {
o.lock.Lock()
defer o.lock.Unlock()
return o.state
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"GetState",
"(",
")",
"PooledObjectState",
"{",
"o",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"o",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"o",
".",
"state",
"\n",
"}"
] | // GetState return current state of this object | [
"GetState",
"return",
"current",
"state",
"of",
"this",
"object"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L157-L161 | train |
jolestar/go-commons-pool | object.go | MarkAbandoned | func (o *PooledObject) MarkAbandoned() {
o.lock.Lock()
o.markAbandoned()
o.lock.Unlock()
} | go | func (o *PooledObject) MarkAbandoned() {
o.lock.Lock()
o.markAbandoned()
o.lock.Unlock()
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"MarkAbandoned",
"(",
")",
"{",
"o",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"o",
".",
"markAbandoned",
"(",
")",
"\n",
"o",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // MarkAbandoned mark this object to Abandoned state | [
"MarkAbandoned",
"mark",
"this",
"object",
"to",
"Abandoned",
"state"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L164-L168 | train |
jolestar/go-commons-pool | object.go | MarkReturning | func (o *PooledObject) MarkReturning() {
o.lock.Lock()
o.markReturning()
o.lock.Unlock()
} | go | func (o *PooledObject) MarkReturning() {
o.lock.Lock()
o.markReturning()
o.lock.Unlock()
} | [
"func",
"(",
"o",
"*",
"PooledObject",
")",
"MarkReturning",
"(",
")",
"{",
"o",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"o",
".",
"markReturning",
"(",
")",
"\n",
"o",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // MarkReturning mark this object to Returning state | [
"MarkReturning",
"mark",
"this",
"object",
"to",
"Returning",
"state"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/object.go#L175-L179 | train |
jolestar/go-commons-pool | collections/queue.go | NewDeque | func NewDeque(capacity int) *LinkedBlockingDeque {
if capacity < 0 {
panic(errors.New("capacity must > 0"))
}
lock := new(sync.Mutex)
return &LinkedBlockingDeque{capacity: capacity, lock: lock, notEmpty: concurrent.NewTimeoutCond(lock), notFull: concurrent.NewTimeoutCond(lock)}
} | go | func NewDeque(capacity int) *LinkedBlockingDeque {
if capacity < 0 {
panic(errors.New("capacity must > 0"))
}
lock := new(sync.Mutex)
return &LinkedBlockingDeque{capacity: capacity, lock: lock, notEmpty: concurrent.NewTimeoutCond(lock), notFull: concurrent.NewTimeoutCond(lock)}
} | [
"func",
"NewDeque",
"(",
"capacity",
"int",
")",
"*",
"LinkedBlockingDeque",
"{",
"if",
"capacity",
"<",
"0",
"{",
"panic",
"(",
"errors",
".",
"New",
"(",
"\"capacity must > 0\"",
")",
")",
"\n",
"}",
"\n",
"lock",
":=",
"new",
"(",
"sync",
".",
"Mute... | // NewDeque return a LinkedBlockingDeque with init capacity | [
"NewDeque",
"return",
"a",
"LinkedBlockingDeque",
"with",
"init",
"capacity"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L77-L83 | train |
jolestar/go-commons-pool | collections/queue.go | linkFirst | func (q *LinkedBlockingDeque) linkFirst(e interface{}) bool {
if q.count >= q.capacity {
return false
}
f := q.first
x := newNode(e, nil, f)
q.first = x
if q.last == nil {
q.last = x
} else {
f.prev = x
}
q.count = q.count + 1
q.notEmpty.Signal()
return true
} | go | func (q *LinkedBlockingDeque) linkFirst(e interface{}) bool {
if q.count >= q.capacity {
return false
}
f := q.first
x := newNode(e, nil, f)
q.first = x
if q.last == nil {
q.last = x
} else {
f.prev = x
}
q.count = q.count + 1
q.notEmpty.Signal()
return true
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"linkFirst",
"(",
"e",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"q",
".",
"count",
">=",
"q",
".",
"capacity",
"{",
"return",
"false",
"\n",
"}",
"\n",
"f",
":=",
"q",
".",
"first",
"\n",
"... | //Links provided element as first element, or returns false if full.
//return true if successful, otherwise false | [
"Links",
"provided",
"element",
"as",
"first",
"element",
"or",
"returns",
"false",
"if",
"full",
".",
"return",
"true",
"if",
"successful",
"otherwise",
"false"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L87-L102 | train |
jolestar/go-commons-pool | collections/queue.go | linkLast | func (q *LinkedBlockingDeque) linkLast(e interface{}) bool {
// assert lock.isHeldByCurrentThread();
if q.count >= q.capacity {
return false
}
l := q.last
x := newNode(e, l, nil)
q.last = x
if q.first == nil {
q.first = x
} else {
l.next = x
}
q.count = q.count + 1
q.notEmpty.Signal()
return true
} | go | func (q *LinkedBlockingDeque) linkLast(e interface{}) bool {
// assert lock.isHeldByCurrentThread();
if q.count >= q.capacity {
return false
}
l := q.last
x := newNode(e, l, nil)
q.last = x
if q.first == nil {
q.first = x
} else {
l.next = x
}
q.count = q.count + 1
q.notEmpty.Signal()
return true
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"linkLast",
"(",
"e",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"q",
".",
"count",
">=",
"q",
".",
"capacity",
"{",
"return",
"false",
"\n",
"}",
"\n",
"l",
":=",
"q",
".",
"last",
"\n",
"x"... | //Links provided element as last element, or returns false if full.
//return true} if successful, otherwise false | [
"Links",
"provided",
"element",
"as",
"last",
"element",
"or",
"returns",
"false",
"if",
"full",
".",
"return",
"true",
"}",
"if",
"successful",
"otherwise",
"false"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L106-L122 | train |
jolestar/go-commons-pool | collections/queue.go | unlinkFirst | func (q *LinkedBlockingDeque) unlinkFirst() interface{} {
// assert lock.isHeldByCurrentThread();
f := q.first
if f == nil {
return nil
}
n := f.next
item := f.item
f.item = nil
f.next = f //help GC
q.first = n
if n == nil {
q.last = nil
} else {
n.prev = nil
}
q.count = q.count - 1
q.notFull.Signal()
return item
} | go | func (q *LinkedBlockingDeque) unlinkFirst() interface{} {
// assert lock.isHeldByCurrentThread();
f := q.first
if f == nil {
return nil
}
n := f.next
item := f.item
f.item = nil
f.next = f //help GC
q.first = n
if n == nil {
q.last = nil
} else {
n.prev = nil
}
q.count = q.count - 1
q.notFull.Signal()
return item
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"unlinkFirst",
"(",
")",
"interface",
"{",
"}",
"{",
"f",
":=",
"q",
".",
"first",
"\n",
"if",
"f",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"n",
":=",
"f",
".",
"next",
"\n",
"item",
... | //Removes and returns the first element, or nil if empty. | [
"Removes",
"and",
"returns",
"the",
"first",
"element",
"or",
"nil",
"if",
"empty",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L125-L144 | train |
jolestar/go-commons-pool | collections/queue.go | unlinkLast | func (q *LinkedBlockingDeque) unlinkLast() interface{} {
l := q.last
if l == nil {
return nil
}
p := l.prev
item := l.item
l.item = nil
l.prev = l // help GC
q.last = p
if p == nil {
q.first = nil
} else {
p.next = nil
}
q.count = q.count - 1
q.notFull.Signal()
return item
} | go | func (q *LinkedBlockingDeque) unlinkLast() interface{} {
l := q.last
if l == nil {
return nil
}
p := l.prev
item := l.item
l.item = nil
l.prev = l // help GC
q.last = p
if p == nil {
q.first = nil
} else {
p.next = nil
}
q.count = q.count - 1
q.notFull.Signal()
return item
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"unlinkLast",
"(",
")",
"interface",
"{",
"}",
"{",
"l",
":=",
"q",
".",
"last",
"\n",
"if",
"l",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"p",
":=",
"l",
".",
"prev",
"\n",
"item",
... | //Removes and returns the last element, or nil if empty. | [
"Removes",
"and",
"returns",
"the",
"last",
"element",
"or",
"nil",
"if",
"empty",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L147-L165 | train |
jolestar/go-commons-pool | collections/queue.go | unlink | func (q *LinkedBlockingDeque) unlink(x *Node) {
// assert lock.isHeldByCurrentThread();
p := x.prev
n := x.next
if p == nil {
q.unlinkFirst()
} else if n == nil {
q.unlinkLast()
} else {
p.next = n
n.prev = p
x.item = nil
// Don't mess with x's links. They may still be in use by
// an iterator.
q.count = q.count - 1
q.notFull.Signal()
}
} | go | func (q *LinkedBlockingDeque) unlink(x *Node) {
// assert lock.isHeldByCurrentThread();
p := x.prev
n := x.next
if p == nil {
q.unlinkFirst()
} else if n == nil {
q.unlinkLast()
} else {
p.next = n
n.prev = p
x.item = nil
// Don't mess with x's links. They may still be in use by
// an iterator.
q.count = q.count - 1
q.notFull.Signal()
}
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"unlink",
"(",
"x",
"*",
"Node",
")",
"{",
"p",
":=",
"x",
".",
"prev",
"\n",
"n",
":=",
"x",
".",
"next",
"\n",
"if",
"p",
"==",
"nil",
"{",
"q",
".",
"unlinkFirst",
"(",
")",
"\n",
"}",
"el... | //Unlink the provided node. | [
"Unlink",
"the",
"provided",
"node",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L168-L185 | train |
jolestar/go-commons-pool | collections/queue.go | AddFirst | func (q *LinkedBlockingDeque) AddFirst(e interface{}) error {
if e == nil {
return errors.New("e is nil")
}
if !q.OfferFirst(e) {
return errors.New("Deque full")
}
return nil
} | go | func (q *LinkedBlockingDeque) AddFirst(e interface{}) error {
if e == nil {
return errors.New("e is nil")
}
if !q.OfferFirst(e) {
return errors.New("Deque full")
}
return nil
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"AddFirst",
"(",
"e",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"e is nil\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"q",
".",
"OfferFi... | // AddFirst inserts the specified element at the front of this deque if it is
// possible to do so immediately without violating capacity restrictions,
// return error if no space is currently available. | [
"AddFirst",
"inserts",
"the",
"specified",
"element",
"at",
"the",
"front",
"of",
"this",
"deque",
"if",
"it",
"is",
"possible",
"to",
"do",
"so",
"immediately",
"without",
"violating",
"capacity",
"restrictions",
"return",
"error",
"if",
"no",
"space",
"is",
... | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L190-L198 | train |
jolestar/go-commons-pool | collections/queue.go | AddLast | func (q *LinkedBlockingDeque) AddLast(e interface{}) error {
if e == nil {
return errors.New("e is nil")
}
if !q.OfferLast(e) {
return errors.New("Deque full")
}
return nil
} | go | func (q *LinkedBlockingDeque) AddLast(e interface{}) error {
if e == nil {
return errors.New("e is nil")
}
if !q.OfferLast(e) {
return errors.New("Deque full")
}
return nil
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"AddLast",
"(",
"e",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"e is nil\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"q",
".",
"OfferLas... | // AddLast inserts the specified element at the end of this deque if it is
// possible to do so immediately without violating capacity restrictions,
// return error if no space is currently available. | [
"AddLast",
"inserts",
"the",
"specified",
"element",
"at",
"the",
"end",
"of",
"this",
"deque",
"if",
"it",
"is",
"possible",
"to",
"do",
"so",
"immediately",
"without",
"violating",
"capacity",
"restrictions",
"return",
"error",
"if",
"no",
"space",
"is",
"... | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L203-L211 | train |
jolestar/go-commons-pool | collections/queue.go | OfferFirst | func (q *LinkedBlockingDeque) OfferFirst(e interface{}) bool {
if e == nil {
return false
}
q.lock.Lock()
result := q.linkFirst(e)
q.lock.Unlock()
return result
} | go | func (q *LinkedBlockingDeque) OfferFirst(e interface{}) bool {
if e == nil {
return false
}
q.lock.Lock()
result := q.linkFirst(e)
q.lock.Unlock()
return result
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"OfferFirst",
"(",
"e",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"result",
":=",
"q... | // OfferFirst inserts the specified element at the front of this deque unless it would violate capacity restrictions.
// return if the element was added to this deque | [
"OfferFirst",
"inserts",
"the",
"specified",
"element",
"at",
"the",
"front",
"of",
"this",
"deque",
"unless",
"it",
"would",
"violate",
"capacity",
"restrictions",
".",
"return",
"if",
"the",
"element",
"was",
"added",
"to",
"this",
"deque"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L215-L223 | train |
jolestar/go-commons-pool | collections/queue.go | OfferLast | func (q *LinkedBlockingDeque) OfferLast(e interface{}) bool {
if e == nil {
return false
}
q.lock.Lock()
result := q.linkLast(e)
q.lock.Unlock()
return result
} | go | func (q *LinkedBlockingDeque) OfferLast(e interface{}) bool {
if e == nil {
return false
}
q.lock.Lock()
result := q.linkLast(e)
q.lock.Unlock()
return result
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"OfferLast",
"(",
"e",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"result",
":=",
"q"... | // OfferLast inserts the specified element at the end of this deque unless it would violate capacity restrictions.
// return if the element was added to this deque | [
"OfferLast",
"inserts",
"the",
"specified",
"element",
"at",
"the",
"end",
"of",
"this",
"deque",
"unless",
"it",
"would",
"violate",
"capacity",
"restrictions",
".",
"return",
"if",
"the",
"element",
"was",
"added",
"to",
"this",
"deque"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L227-L235 | train |
jolestar/go-commons-pool | collections/queue.go | PutFirst | func (q *LinkedBlockingDeque) PutFirst(ctx context.Context, e interface{}) {
if e == nil {
return
}
q.lock.Lock()
defer q.lock.Unlock()
for !q.linkFirst(e) {
q.notFull.Wait(ctx)
}
} | go | func (q *LinkedBlockingDeque) PutFirst(ctx context.Context, e interface{}) {
if e == nil {
return
}
q.lock.Lock()
defer q.lock.Unlock()
for !q.linkFirst(e) {
q.notFull.Wait(ctx)
}
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"PutFirst",
"(",
"ctx",
"context",
".",
"Context",
",",
"e",
"interface",
"{",
"}",
")",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n"... | // PutFirst link the provided element as the first in the queue, waiting until there
// is space to do so if the queue is full. | [
"PutFirst",
"link",
"the",
"provided",
"element",
"as",
"the",
"first",
"in",
"the",
"queue",
"waiting",
"until",
"there",
"is",
"space",
"to",
"do",
"so",
"if",
"the",
"queue",
"is",
"full",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L239-L248 | train |
jolestar/go-commons-pool | collections/queue.go | PutLast | func (q *LinkedBlockingDeque) PutLast(ctx context.Context, e interface{}) {
if e == nil {
return
}
q.lock.Lock()
defer q.lock.Unlock()
for !q.linkLast(e) {
q.notFull.Wait(ctx)
}
} | go | func (q *LinkedBlockingDeque) PutLast(ctx context.Context, e interface{}) {
if e == nil {
return
}
q.lock.Lock()
defer q.lock.Unlock()
for !q.linkLast(e) {
q.notFull.Wait(ctx)
}
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"PutLast",
"(",
"ctx",
"context",
".",
"Context",
",",
"e",
"interface",
"{",
"}",
")",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",... | // PutLast Link the provided element as the last in the queue, waiting until there
// is space to do so if the queue is full. | [
"PutLast",
"Link",
"the",
"provided",
"element",
"as",
"the",
"last",
"in",
"the",
"queue",
"waiting",
"until",
"there",
"is",
"space",
"to",
"do",
"so",
"if",
"the",
"queue",
"is",
"full",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L252-L261 | train |
jolestar/go-commons-pool | collections/queue.go | PollFirst | func (q *LinkedBlockingDeque) PollFirst() (e interface{}) {
q.lock.Lock()
result := q.unlinkFirst()
q.lock.Unlock()
return result
} | go | func (q *LinkedBlockingDeque) PollFirst() (e interface{}) {
q.lock.Lock()
result := q.unlinkFirst()
q.lock.Unlock()
return result
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"PollFirst",
"(",
")",
"(",
"e",
"interface",
"{",
"}",
")",
"{",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"result",
":=",
"q",
".",
"unlinkFirst",
"(",
")",
"\n",
"q",
".",
"lock",
".",
... | // PollFirst retrieves and removes the first element of this deque,
// or returns nil if this deque is empty. | [
"PollFirst",
"retrieves",
"and",
"removes",
"the",
"first",
"element",
"of",
"this",
"deque",
"or",
"returns",
"nil",
"if",
"this",
"deque",
"is",
"empty",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L265-L270 | train |
jolestar/go-commons-pool | collections/queue.go | PollLast | func (q *LinkedBlockingDeque) PollLast() interface{} {
q.lock.Lock()
result := q.unlinkLast()
q.lock.Unlock()
return result
} | go | func (q *LinkedBlockingDeque) PollLast() interface{} {
q.lock.Lock()
result := q.unlinkLast()
q.lock.Unlock()
return result
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"PollLast",
"(",
")",
"interface",
"{",
"}",
"{",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"result",
":=",
"q",
".",
"unlinkLast",
"(",
")",
"\n",
"q",
".",
"lock",
".",
"Unlock",
"(",
")",... | // PollLast retrieves and removes the last element of this deque,
// or returns nil if this deque is empty. | [
"PollLast",
"retrieves",
"and",
"removes",
"the",
"last",
"element",
"of",
"this",
"deque",
"or",
"returns",
"nil",
"if",
"this",
"deque",
"is",
"empty",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L296-L301 | train |
jolestar/go-commons-pool | collections/queue.go | TakeFirst | func (q *LinkedBlockingDeque) TakeFirst(ctx context.Context) (interface{}, error) {
q.lock.Lock()
defer q.lock.Unlock()
var x interface{}
interrupt := false
for x = q.unlinkFirst(); x == nil; x = q.unlinkFirst() {
if interrupt {
return nil, NewInterruptedErr()
}
interrupt = q.notEmpty.Wait(ctx)
}
return x, nil
} | go | func (q *LinkedBlockingDeque) TakeFirst(ctx context.Context) (interface{}, error) {
q.lock.Lock()
defer q.lock.Unlock()
var x interface{}
interrupt := false
for x = q.unlinkFirst(); x == nil; x = q.unlinkFirst() {
if interrupt {
return nil, NewInterruptedErr()
}
interrupt = q.notEmpty.Wait(ctx)
}
return x, nil
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"TakeFirst",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"q",
".",
"lock",
".",
"Unlock",... | // TakeFirst unlink the first element in the queue, waiting until there is an element
// to unlink if the queue is empty.
// return NewInterruptedErr if wait condition is interrupted | [
"TakeFirst",
"unlink",
"the",
"first",
"element",
"in",
"the",
"queue",
"waiting",
"until",
"there",
"is",
"an",
"element",
"to",
"unlink",
"if",
"the",
"queue",
"is",
"empty",
".",
"return",
"NewInterruptedErr",
"if",
"wait",
"condition",
"is",
"interrupted"
... | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L328-L340 | train |
jolestar/go-commons-pool | collections/queue.go | PeekFirst | func (q *LinkedBlockingDeque) PeekFirst() interface{} {
var result interface{}
q.lock.Lock()
if q.first == nil {
result = nil
} else {
result = q.first.item
}
q.lock.Unlock()
return result
} | go | func (q *LinkedBlockingDeque) PeekFirst() interface{} {
var result interface{}
q.lock.Lock()
if q.first == nil {
result = nil
} else {
result = q.first.item
}
q.lock.Unlock()
return result
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"PeekFirst",
"(",
")",
"interface",
"{",
"}",
"{",
"var",
"result",
"interface",
"{",
"}",
"\n",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"if",
"q",
".",
"first",
"==",
"nil",
"{",
"result",
... | // PeekFirst retrieves, but does not remove, the first element of this deque,
// or returns nil if this deque is empty. | [
"PeekFirst",
"retrieves",
"but",
"does",
"not",
"remove",
"the",
"first",
"element",
"of",
"this",
"deque",
"or",
"returns",
"nil",
"if",
"this",
"deque",
"is",
"empty",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L361-L371 | train |
jolestar/go-commons-pool | collections/queue.go | PeekLast | func (q *LinkedBlockingDeque) PeekLast() interface{} {
var result interface{}
q.lock.Lock()
if q.last == nil {
result = nil
} else {
result = q.last.item
}
q.lock.Unlock()
return result
} | go | func (q *LinkedBlockingDeque) PeekLast() interface{} {
var result interface{}
q.lock.Lock()
if q.last == nil {
result = nil
} else {
result = q.last.item
}
q.lock.Unlock()
return result
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"PeekLast",
"(",
")",
"interface",
"{",
"}",
"{",
"var",
"result",
"interface",
"{",
"}",
"\n",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"if",
"q",
".",
"last",
"==",
"nil",
"{",
"result",
... | // PeekLast retrieves, but does not remove, the last element of this deque,
// or returns nil if this deque is empty. | [
"PeekLast",
"retrieves",
"but",
"does",
"not",
"remove",
"the",
"last",
"element",
"of",
"this",
"deque",
"or",
"returns",
"nil",
"if",
"this",
"deque",
"is",
"empty",
"."
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L375-L385 | train |
jolestar/go-commons-pool | collections/queue.go | Size | func (q *LinkedBlockingDeque) Size() int {
q.lock.Lock()
defer q.lock.Unlock()
return q.size()
} | go | func (q *LinkedBlockingDeque) Size() int {
q.lock.Lock()
defer q.lock.Unlock()
return q.size()
} | [
"func",
"(",
"q",
"*",
"LinkedBlockingDeque",
")",
"Size",
"(",
")",
"int",
"{",
"q",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"q",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"q",
".",
"size",
"(",
")",
"\n",
"}"
] | // Size return this LinkedBlockingDeque current elements len, is concurrent safe | [
"Size",
"return",
"this",
"LinkedBlockingDeque",
"current",
"elements",
"len",
"is",
"concurrent",
"safe"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L457-L461 | train |
jolestar/go-commons-pool | collections/queue.go | Next | func (iterator *LinkedBlockingDequeIterator) Next() interface{} {
if iterator.next == nil {
//TODO error or nil ?
//panic(errors.New("NoSuchElement"))
return nil
}
iterator.lastRet = iterator.next
x := iterator.nextItem
iterator.advance()
return x
} | go | func (iterator *LinkedBlockingDequeIterator) Next() interface{} {
if iterator.next == nil {
//TODO error or nil ?
//panic(errors.New("NoSuchElement"))
return nil
}
iterator.lastRet = iterator.next
x := iterator.nextItem
iterator.advance()
return x
} | [
"func",
"(",
"iterator",
"*",
"LinkedBlockingDequeIterator",
")",
"Next",
"(",
")",
"interface",
"{",
"}",
"{",
"if",
"iterator",
".",
"next",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"iterator",
".",
"lastRet",
"=",
"iterator",
".",
"next",
... | // Next return next element, if not exist will return nil | [
"Next",
"return",
"next",
"element",
"if",
"not",
"exist",
"will",
"return",
"nil"
] | 5cc5d37d092a27de00a69e4501f50bb4ead1b304 | https://github.com/jolestar/go-commons-pool/blob/5cc5d37d092a27de00a69e4501f50bb4ead1b304/collections/queue.go#L519-L529 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.