id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
140,800 | signalfx/golib | log/log.go | NewContext | func NewContext(logger Logger) *Context {
if logger == nil {
return nil
}
if c, ok := logger.(*Context); ok {
return c
}
ctx := &Context{
Logger: logger,
}
return ctx
} | go | func NewContext(logger Logger) *Context {
if logger == nil {
return nil
}
if c, ok := logger.(*Context); ok {
return c
}
ctx := &Context{
Logger: logger,
}
return ctx
} | [
"func",
"NewContext",
"(",
"logger",
"Logger",
")",
"*",
"Context",
"{",
"if",
"logger",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"c",
",",
"ok",
":=",
"logger",
".",
"(",
"*",
"Context",
")",
";",
"ok",
"{",
"return",
"c",
"\n",... | // NewContext creates a context out of a logger | [
"NewContext",
"creates",
"a",
"context",
"out",
"of",
"a",
"logger"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/log.go#L48-L59 |
140,801 | signalfx/golib | log/log.go | IfErr | func IfErr(l Logger, err error) {
if err != nil {
l.Log(Err, err)
}
} | go | func IfErr(l Logger, err error) {
if err != nil {
l.Log(Err, err)
}
} | [
"func",
"IfErr",
"(",
"l",
"Logger",
",",
"err",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"l",
".",
"Log",
"(",
"Err",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // IfErr is a shorthand that will log an error if err is not nil | [
"IfErr",
"is",
"a",
"shorthand",
"that",
"will",
"log",
"an",
"error",
"if",
"err",
"is",
"not",
"nil"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/log.go#L139-L143 |
140,802 | signalfx/golib | log/log.go | IfErrAndReturn | func IfErrAndReturn(l Logger, err error) error {
if err != nil {
l.Log(Err, err)
}
return err
} | go | func IfErrAndReturn(l Logger, err error) error {
if err != nil {
l.Log(Err, err)
}
return err
} | [
"func",
"IfErrAndReturn",
"(",
"l",
"Logger",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"!=",
"nil",
"{",
"l",
".",
"Log",
"(",
"Err",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // IfErrAndReturn is a shorthand that will log an error if err is not nil and returns the original err | [
"IfErrAndReturn",
"is",
"a",
"shorthand",
"that",
"will",
"log",
"an",
"error",
"if",
"err",
"is",
"not",
"nil",
"and",
"returns",
"the",
"original",
"err"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/log.go#L146-L151 |
140,803 | signalfx/golib | log/logfmt.go | NewLogfmtLogger | func NewLogfmtLogger(w io.Writer, ErrHandler ErrorHandler) Logger {
if w == ioutil.Discard {
return Discard
}
return &ErrorLogLogger{
RootLogger: &LogfmtLogger{
Out: w,
MissingValueKey: Msg,
},
ErrHandler: ErrHandler,
}
} | go | func NewLogfmtLogger(w io.Writer, ErrHandler ErrorHandler) Logger {
if w == ioutil.Discard {
return Discard
}
return &ErrorLogLogger{
RootLogger: &LogfmtLogger{
Out: w,
MissingValueKey: Msg,
},
ErrHandler: ErrHandler,
}
} | [
"func",
"NewLogfmtLogger",
"(",
"w",
"io",
".",
"Writer",
",",
"ErrHandler",
"ErrorHandler",
")",
"Logger",
"{",
"if",
"w",
"==",
"ioutil",
".",
"Discard",
"{",
"return",
"Discard",
"\n",
"}",
"\n",
"return",
"&",
"ErrorLogLogger",
"{",
"RootLogger",
":",
... | // NewLogfmtLogger returns a logger that encodes keyvals to the Writer in
// logfmt format. The passed Writer must be safe for concurrent use by
// multiple goroutines if the returned Logger will be used concurrently. | [
"NewLogfmtLogger",
"returns",
"a",
"logger",
"that",
"encodes",
"keyvals",
"to",
"the",
"Writer",
"in",
"logfmt",
"format",
".",
"The",
"passed",
"Writer",
"must",
"be",
"safe",
"for",
"concurrent",
"use",
"by",
"multiple",
"goroutines",
"if",
"the",
"returned... | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/logfmt.go#L19-L30 |
140,804 | signalfx/golib | log/logfmt.go | Log | func (l *LogfmtLogger) Log(keyvals ...interface{}) error {
// The Logger interface requires implementations to be safe for concurrent
// use by multiple goroutines. For this implementation that means making
// only one call to l.w.Write() for each call to Log. We first collect all
// of the bytes into b, and then c... | go | func (l *LogfmtLogger) Log(keyvals ...interface{}) error {
// The Logger interface requires implementations to be safe for concurrent
// use by multiple goroutines. For this implementation that means making
// only one call to l.w.Write() for each call to Log. We first collect all
// of the bytes into b, and then c... | [
"func",
"(",
"l",
"*",
"LogfmtLogger",
")",
"Log",
"(",
"keyvals",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"// The Logger interface requires implementations to be safe for concurrent",
"// use by multiple goroutines. For this implementation that means making",
"// only o... | // Log writes the keyvalus in logfmt format to Out | [
"Log",
"writes",
"the",
"keyvalus",
"in",
"logfmt",
"format",
"to",
"Out"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/logfmt.go#L33-L50 |
140,805 | signalfx/golib | log/dynamic.go | LogValue | func (t *TimeDynamic) LogValue() interface{} {
var now time.Time
if t.TimeKeeper == nil {
now = time.Now()
} else {
now = t.TimeKeeper.Now()
}
if t.UTC {
now = now.UTC()
}
if !t.AsString {
return now
}
if t.Layout == "" {
return now.Format(time.RFC3339)
}
return now.Format(t.Layout)
} | go | func (t *TimeDynamic) LogValue() interface{} {
var now time.Time
if t.TimeKeeper == nil {
now = time.Now()
} else {
now = t.TimeKeeper.Now()
}
if t.UTC {
now = now.UTC()
}
if !t.AsString {
return now
}
if t.Layout == "" {
return now.Format(time.RFC3339)
}
return now.Format(t.Layout)
} | [
"func",
"(",
"t",
"*",
"TimeDynamic",
")",
"LogValue",
"(",
")",
"interface",
"{",
"}",
"{",
"var",
"now",
"time",
".",
"Time",
"\n",
"if",
"t",
".",
"TimeKeeper",
"==",
"nil",
"{",
"now",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"else",
"... | // LogValue returns a timestamp as described by parameters | [
"LogValue",
"returns",
"a",
"timestamp",
"as",
"described",
"by",
"parameters"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/dynamic.go#L66-L83 |
140,806 | signalfx/golib | log/dynamic.go | LogValue | func (c *TimeSince) LogValue() interface{} {
nowFunc := time.Now
if c.TimeKeeper != nil {
nowFunc = c.TimeKeeper.Now
}
if c.Start.IsZero() {
return nowFunc().Sub(defaultStartTime)
}
return nowFunc().Sub(c.Start)
} | go | func (c *TimeSince) LogValue() interface{} {
nowFunc := time.Now
if c.TimeKeeper != nil {
nowFunc = c.TimeKeeper.Now
}
if c.Start.IsZero() {
return nowFunc().Sub(defaultStartTime)
}
return nowFunc().Sub(c.Start)
} | [
"func",
"(",
"c",
"*",
"TimeSince",
")",
"LogValue",
"(",
")",
"interface",
"{",
"}",
"{",
"nowFunc",
":=",
"time",
".",
"Now",
"\n",
"if",
"c",
".",
"TimeKeeper",
"!=",
"nil",
"{",
"nowFunc",
"=",
"c",
".",
"TimeKeeper",
".",
"Now",
"\n",
"}",
"... | // LogValue returs the time since Start time | [
"LogValue",
"returs",
"the",
"time",
"since",
"Start",
"time"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/dynamic.go#L94-L103 |
140,807 | signalfx/golib | distconf/bool.go | Update | func (s *boolConf) Update(newValue []byte) error {
s.mutex.Lock()
defer s.mutex.Unlock()
oldValue := s.Get()
if newValue == nil {
atomic.StoreInt32(&s.currentVal, s.defaultVal)
} else {
newValueStr := string(newValue)
if parsedBool, err := strconv.ParseBool(newValueStr); err != nil {
atomic.StoreInt32(&s.... | go | func (s *boolConf) Update(newValue []byte) error {
s.mutex.Lock()
defer s.mutex.Unlock()
oldValue := s.Get()
if newValue == nil {
atomic.StoreInt32(&s.currentVal, s.defaultVal)
} else {
newValueStr := string(newValue)
if parsedBool, err := strconv.ParseBool(newValueStr); err != nil {
atomic.StoreInt32(&s.... | [
"func",
"(",
"s",
"*",
"boolConf",
")",
"Update",
"(",
"newValue",
"[",
"]",
"byte",
")",
"error",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"oldValue",
":=",
"s",
".",
"Get"... | // Update the contents of Bool to the new value | [
"Update",
"the",
"contents",
"of",
"Bool",
"to",
"the",
"new",
"value"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/bool.go#L28-L50 |
140,808 | signalfx/golib | errors/multi.go | NewMultiErr | func NewMultiErr(errs []error) error {
retErrs := make([]error, 0, len(errs))
for _, err := range errs {
if err != nil {
retErrs = append(retErrs, err)
}
}
if len(retErrs) == 0 {
return nil
}
if len(retErrs) == 1 {
return retErrs[0]
}
return &MultiErr{
errs: retErrs,
}
} | go | func NewMultiErr(errs []error) error {
retErrs := make([]error, 0, len(errs))
for _, err := range errs {
if err != nil {
retErrs = append(retErrs, err)
}
}
if len(retErrs) == 0 {
return nil
}
if len(retErrs) == 1 {
return retErrs[0]
}
return &MultiErr{
errs: retErrs,
}
} | [
"func",
"NewMultiErr",
"(",
"errs",
"[",
"]",
"error",
")",
"error",
"{",
"retErrs",
":=",
"make",
"(",
"[",
"]",
"error",
",",
"0",
",",
"len",
"(",
"errs",
")",
")",
"\n",
"for",
"_",
",",
"err",
":=",
"range",
"errs",
"{",
"if",
"err",
"!=",... | // NewMultiErr will return nil if there are no valid errors in errs, will return the exact, single error
// if errs only contains a single error, and will otherwise return an instance of MultiErr that wraps all
// the errors at once. | [
"NewMultiErr",
"will",
"return",
"nil",
"if",
"there",
"are",
"no",
"valid",
"errors",
"in",
"errs",
"will",
"return",
"the",
"exact",
"single",
"error",
"if",
"errs",
"only",
"contains",
"a",
"single",
"error",
"and",
"will",
"otherwise",
"return",
"an",
... | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/errors/multi.go#L23-L39 |
140,809 | signalfx/golib | errors/analyze.go | Next | func Next(err error) error {
if tail, ok := err.(errLinkedList); ok {
return tail.Next()
}
if u, ok := err.(hasUnderline); ok {
return u.Underlying()
}
if i, ok := err.(hasInner); ok {
return i.GetInner()
}
return nil
} | go | func Next(err error) error {
if tail, ok := err.(errLinkedList); ok {
return tail.Next()
}
if u, ok := err.(hasUnderline); ok {
return u.Underlying()
}
if i, ok := err.(hasInner); ok {
return i.GetInner()
}
return nil
} | [
"func",
"Next",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"tail",
",",
"ok",
":=",
"err",
".",
"(",
"errLinkedList",
")",
";",
"ok",
"{",
"return",
"tail",
".",
"Next",
"(",
")",
"\n",
"}",
"\n",
"if",
"u",
",",
"ok",
":=",
"err",
".",
"(... | // Next error just below this one, or nil if there is no next error. Note this may be an error created
// for you if you used annotations. As a user, you probably don't want to use this. | [
"Next",
"error",
"just",
"below",
"this",
"one",
"or",
"nil",
"if",
"there",
"is",
"no",
"next",
"error",
".",
"Note",
"this",
"may",
"be",
"an",
"error",
"created",
"for",
"you",
"if",
"you",
"used",
"annotations",
".",
"As",
"a",
"user",
"you",
"pr... | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/errors/analyze.go#L27-L38 |
140,810 | signalfx/golib | errors/analyze.go | Message | func Message(err error) string {
if tail, ok := err.(errLinkedList); ok {
return tail.Head().Error()
}
if hasMsg, ok := err.(hasMessage); ok {
return hasMsg.Message()
}
return err.Error()
} | go | func Message(err error) string {
if tail, ok := err.(errLinkedList); ok {
return tail.Head().Error()
}
if hasMsg, ok := err.(hasMessage); ok {
return hasMsg.Message()
}
return err.Error()
} | [
"func",
"Message",
"(",
"err",
"error",
")",
"string",
"{",
"if",
"tail",
",",
"ok",
":=",
"err",
".",
"(",
"errLinkedList",
")",
";",
"ok",
"{",
"return",
"tail",
".",
"Head",
"(",
")",
".",
"Error",
"(",
")",
"\n",
"}",
"\n",
"if",
"hasMsg",
... | // Message is the error string at the Head of the linked list | [
"Message",
"is",
"the",
"error",
"string",
"at",
"the",
"Head",
"of",
"the",
"linked",
"list"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/errors/analyze.go#L41-L49 |
140,811 | signalfx/golib | errors/analyze.go | Details | func Details(err error) string {
b := bytes.Buffer{}
PanicIfErr(b.WriteByte('['), "unexpected")
first := true
for ; err != nil; err = Next(err) {
if !first {
PanicIfErrWrite(b.WriteString(" | "))
}
PanicIfErrWrite(b.WriteString(Message(err)))
first = false
}
PanicIfErr(b.WriteByte(']'), "unexpected")
... | go | func Details(err error) string {
b := bytes.Buffer{}
PanicIfErr(b.WriteByte('['), "unexpected")
first := true
for ; err != nil; err = Next(err) {
if !first {
PanicIfErrWrite(b.WriteString(" | "))
}
PanicIfErrWrite(b.WriteString(Message(err)))
first = false
}
PanicIfErr(b.WriteByte(']'), "unexpected")
... | [
"func",
"Details",
"(",
"err",
"error",
")",
"string",
"{",
"b",
":=",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"PanicIfErr",
"(",
"b",
".",
"WriteByte",
"(",
"'['",
")",
",",
"\"",
"\"",
")",
"\n",
"first",
":=",
"true",
"\n",
"for",
";",
"err",
... | // Details are an easy to read concat of all the error strings in a chain | [
"Details",
"are",
"an",
"easy",
"to",
"read",
"concat",
"of",
"all",
"the",
"error",
"strings",
"in",
"a",
"chain"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/errors/analyze.go#L52-L65 |
140,812 | signalfx/golib | errors/constructors.go | Annotate | func Annotate(err error, msg string) error {
if err == nil {
return nil
}
return Wrap(errors.New(msg), err)
} | go | func Annotate(err error, msg string) error {
if err == nil {
return nil
}
return Wrap(errors.New(msg), err)
} | [
"func",
"Annotate",
"(",
"err",
"error",
",",
"msg",
"string",
")",
"error",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"Wrap",
"(",
"errors",
".",
"New",
"(",
"msg",
")",
",",
"err",
")",
"\n",
"}"
] | // Annotate adds a new error in the chain that is some extra context about the error | [
"Annotate",
"adds",
"a",
"new",
"error",
"in",
"the",
"chain",
"that",
"is",
"some",
"extra",
"context",
"about",
"the",
"error"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/errors/constructors.go#L19-L24 |
140,813 | signalfx/golib | errors/constructors.go | Annotatef | func Annotatef(err error, msg string, args ...interface{}) error {
if err == nil {
return nil
}
return Wrap(fmt.Errorf(msg, args...), err)
} | go | func Annotatef(err error, msg string, args ...interface{}) error {
if err == nil {
return nil
}
return Wrap(fmt.Errorf(msg, args...), err)
} | [
"func",
"Annotatef",
"(",
"err",
"error",
",",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"Wrap",
"(",
"fmt",
".",
"Errorf",
"(",
"msg",
... | // Annotatef adds a new formatf error in the chain that is some extra context about the error | [
"Annotatef",
"adds",
"a",
"new",
"formatf",
"error",
"in",
"the",
"chain",
"that",
"is",
"some",
"extra",
"context",
"about",
"the",
"error"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/errors/constructors.go#L27-L32 |
140,814 | signalfx/golib | errors/constructors.go | Wrap | func Wrap(head error, next error) error {
if head == nil {
// The state head==nil && next!=nil is very strange so I leave it as nil
return nil
}
if next == nil {
return head
}
tail := Tail(next)
return &ErrorChain{
head: head,
next: next,
tail: tail,
}
} | go | func Wrap(head error, next error) error {
if head == nil {
// The state head==nil && next!=nil is very strange so I leave it as nil
return nil
}
if next == nil {
return head
}
tail := Tail(next)
return &ErrorChain{
head: head,
next: next,
tail: tail,
}
} | [
"func",
"Wrap",
"(",
"head",
"error",
",",
"next",
"error",
")",
"error",
"{",
"if",
"head",
"==",
"nil",
"{",
"// The state head==nil && next!=nil is very strange so I leave it as nil",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"next",
"==",
"nil",
"{",
"return",... | // Wrap a head function giving it the chain defined in next. Note that wrap may sometimes return head directly
// if next is nil | [
"Wrap",
"a",
"head",
"function",
"giving",
"it",
"the",
"chain",
"defined",
"in",
"next",
".",
"Note",
"that",
"wrap",
"may",
"sometimes",
"return",
"head",
"directly",
"if",
"next",
"is",
"nil"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/errors/constructors.go#L36-L50 |
140,815 | signalfx/golib | pointer/pointer.go | FillDefaultFrom | func FillDefaultFrom(defaultsList ...interface{}) interface{} {
if len(defaultsList) == 0 {
return nil
}
rootType := reflect.TypeOf(defaultsList[0])
if rootType.Kind() != reflect.Ptr {
panic(fmt.Sprintf("FillDefaultsFrom only takes pointer types, not %s", rootType))
}
typeToMake := rootType.Elem()
existing... | go | func FillDefaultFrom(defaultsList ...interface{}) interface{} {
if len(defaultsList) == 0 {
return nil
}
rootType := reflect.TypeOf(defaultsList[0])
if rootType.Kind() != reflect.Ptr {
panic(fmt.Sprintf("FillDefaultsFrom only takes pointer types, not %s", rootType))
}
typeToMake := rootType.Elem()
existing... | [
"func",
"FillDefaultFrom",
"(",
"defaultsList",
"...",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"if",
"len",
"(",
"defaultsList",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"rootType",
":=",
"reflect",
".",
"TypeOf",
"(",
"... | // FillDefaultFrom fills default values replacing nil values with the first non nil. The replacement goes into existing | [
"FillDefaultFrom",
"fills",
"default",
"values",
"replacing",
"nil",
"values",
"with",
"the",
"first",
"non",
"nil",
".",
"The",
"replacement",
"goes",
"into",
"existing"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/pointer/pointer.go#L74-L104 |
140,816 | signalfx/golib | errors/matcher.go | MatchesI | func MatchesI(err error, m Matcher) bool {
return m.Matches(Cause(err))
} | go | func MatchesI(err error, m Matcher) bool {
return m.Matches(Cause(err))
} | [
"func",
"MatchesI",
"(",
"err",
"error",
",",
"m",
"Matcher",
")",
"bool",
"{",
"return",
"m",
".",
"Matches",
"(",
"Cause",
"(",
"err",
")",
")",
"\n",
"}"
] | // MatchesI is like Matches but takes the interface, if you need it. | [
"MatchesI",
"is",
"like",
"Matches",
"but",
"takes",
"the",
"interface",
"if",
"you",
"need",
"it",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/errors/matcher.go#L27-L29 |
140,817 | signalfx/golib | datapoint/dplocal/local.go | NewOnHostDatapoint | func NewOnHostDatapoint(metric string, value datapoint.Value, metricType datapoint.MetricType) *datapoint.Datapoint {
return NewOnHostDatapointDimensions(metric, value, metricType, map[string]string{})
} | go | func NewOnHostDatapoint(metric string, value datapoint.Value, metricType datapoint.MetricType) *datapoint.Datapoint {
return NewOnHostDatapointDimensions(metric, value, metricType, map[string]string{})
} | [
"func",
"NewOnHostDatapoint",
"(",
"metric",
"string",
",",
"value",
"datapoint",
".",
"Value",
",",
"metricType",
"datapoint",
".",
"MetricType",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"NewOnHostDatapointDimensions",
"(",
"metric",
",",
"value",
... | // NewOnHostDatapoint is like NewSingleNameDataPointWithType but also a source
// of this host | [
"NewOnHostDatapoint",
"is",
"like",
"NewSingleNameDataPointWithType",
"but",
"also",
"a",
"source",
"of",
"this",
"host"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/dplocal/local.go#L13-L15 |
140,818 | signalfx/golib | datapoint/dplocal/local.go | NewOnHostDatapointDimensions | func NewOnHostDatapointDimensions(metric string, value datapoint.Value, metricType datapoint.MetricType, dimensions map[string]string) *datapoint.Datapoint {
return Wrap(datapoint.New(metric, dimensions, value, metricType, time.Now()))
} | go | func NewOnHostDatapointDimensions(metric string, value datapoint.Value, metricType datapoint.MetricType, dimensions map[string]string) *datapoint.Datapoint {
return Wrap(datapoint.New(metric, dimensions, value, metricType, time.Now()))
} | [
"func",
"NewOnHostDatapointDimensions",
"(",
"metric",
"string",
",",
"value",
"datapoint",
".",
"Value",
",",
"metricType",
"datapoint",
".",
"MetricType",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"... | // NewOnHostDatapointDimensions is like NewOnHostDatapoint but also with optional dimensions | [
"NewOnHostDatapointDimensions",
"is",
"like",
"NewOnHostDatapoint",
"but",
"also",
"with",
"optional",
"dimensions"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/dplocal/local.go#L18-L20 |
140,819 | signalfx/golib | datapoint/dplocal/local.go | Wrap | func Wrap(dp *datapoint.Datapoint) *datapoint.Datapoint {
hostname, err := osXXXHostname()
if dp.Dimensions == nil {
dp.Dimensions = make(map[string]string, 2)
}
if err != nil {
hostname = "unknown"
}
dp.Dimensions["host"] = hostname
dp.Dimensions["source"] = "proxy"
return dp
} | go | func Wrap(dp *datapoint.Datapoint) *datapoint.Datapoint {
hostname, err := osXXXHostname()
if dp.Dimensions == nil {
dp.Dimensions = make(map[string]string, 2)
}
if err != nil {
hostname = "unknown"
}
dp.Dimensions["host"] = hostname
dp.Dimensions["source"] = "proxy"
return dp
} | [
"func",
"Wrap",
"(",
"dp",
"*",
"datapoint",
".",
"Datapoint",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"hostname",
",",
"err",
":=",
"osXXXHostname",
"(",
")",
"\n",
"if",
"dp",
".",
"Dimensions",
"==",
"nil",
"{",
"dp",
".",
"Dimensions",
"=",
... | // Wrap a normal datapoint to give it dimensions about the current hostname | [
"Wrap",
"a",
"normal",
"datapoint",
"to",
"give",
"it",
"dimensions",
"about",
"the",
"current",
"hostname"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/dplocal/local.go#L23-L34 |
140,820 | signalfx/golib | event/event.go | New | func New(eventType string, category Category, dimensions map[string]string, timestamp time.Time) *Event {
return NewWithProperties(eventType, category, dimensions, map[string]interface{}{}, timestamp)
} | go | func New(eventType string, category Category, dimensions map[string]string, timestamp time.Time) *Event {
return NewWithProperties(eventType, category, dimensions, map[string]interface{}{}, timestamp)
} | [
"func",
"New",
"(",
"eventType",
"string",
",",
"category",
"Category",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"timestamp",
"time",
".",
"Time",
")",
"*",
"Event",
"{",
"return",
"NewWithProperties",
"(",
"eventType",
",",
"category",
... | // New creates a new event with empty meta data | [
"New",
"creates",
"a",
"new",
"event",
"with",
"empty",
"meta",
"data"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/event/event.go#L60-L62 |
140,821 | signalfx/golib | event/event.go | ToProtoEC | func ToProtoEC(ec com_signalfx_metrics_protobuf.EventCategory) Category {
var response = USERDEFINED
// Check if the event.Category does not have a corresponding com_signalfx_metrics_protobuf.EventCategory
if _, ok := com_signalfx_metrics_protobuf.EventCategory_name[int32(ec)]; ok {
response = Category(int32(ec))
... | go | func ToProtoEC(ec com_signalfx_metrics_protobuf.EventCategory) Category {
var response = USERDEFINED
// Check if the event.Category does not have a corresponding com_signalfx_metrics_protobuf.EventCategory
if _, ok := com_signalfx_metrics_protobuf.EventCategory_name[int32(ec)]; ok {
response = Category(int32(ec))
... | [
"func",
"ToProtoEC",
"(",
"ec",
"com_signalfx_metrics_protobuf",
".",
"EventCategory",
")",
"Category",
"{",
"var",
"response",
"=",
"USERDEFINED",
"\n",
"// Check if the event.Category does not have a corresponding com_signalfx_metrics_protobuf.EventCategory",
"if",
"_",
",",
... | // ToProtoEC - Converts a protbuf EventCategory to type event.Category | [
"ToProtoEC",
"-",
"Converts",
"a",
"protbuf",
"EventCategory",
"to",
"type",
"event",
".",
"Category"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/event/event.go#L65-L73 |
140,822 | signalfx/golib | event/event.go | NewWithProperties | func NewWithProperties(eventType string, category Category, dimensions map[string]string, properties map[string]interface{}, timestamp time.Time) *Event {
return &Event{
EventType: eventType,
Category: category,
Dimensions: dimensions,
Properties: properties,
Timestamp: timestamp,
}
} | go | func NewWithProperties(eventType string, category Category, dimensions map[string]string, properties map[string]interface{}, timestamp time.Time) *Event {
return &Event{
EventType: eventType,
Category: category,
Dimensions: dimensions,
Properties: properties,
Timestamp: timestamp,
}
} | [
"func",
"NewWithProperties",
"(",
"eventType",
"string",
",",
"category",
"Category",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"properties",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"timestamp",
"time",
".",
"Time",
")",
"... | // NewWithProperties creates a new event with passed metadata | [
"NewWithProperties",
"creates",
"a",
"new",
"event",
"with",
"passed",
"metadata"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/event/event.go#L76-L84 |
140,823 | signalfx/golib | sfxclient/timerange.go | Add | func (t *TimeCounter) Add(dur time.Duration) {
if dur.Nanoseconds() <= atomic.LoadInt64(&t.NsBarrier) {
atomic.AddInt64(&t.Below, 1)
return
}
atomic.AddInt64(&t.Above, 1)
} | go | func (t *TimeCounter) Add(dur time.Duration) {
if dur.Nanoseconds() <= atomic.LoadInt64(&t.NsBarrier) {
atomic.AddInt64(&t.Below, 1)
return
}
atomic.AddInt64(&t.Above, 1)
} | [
"func",
"(",
"t",
"*",
"TimeCounter",
")",
"Add",
"(",
"dur",
"time",
".",
"Duration",
")",
"{",
"if",
"dur",
".",
"Nanoseconds",
"(",
")",
"<=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"t",
".",
"NsBarrier",
")",
"{",
"atomic",
".",
"AddInt64",
"(",... | // Add includes a datapoint in the source, incrementing above or below according to barrier | [
"Add",
"includes",
"a",
"datapoint",
"in",
"the",
"source",
"incrementing",
"above",
"or",
"below",
"according",
"to",
"barrier"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/timerange.go#L18-L24 |
140,824 | signalfx/golib | sfxclient/timerange.go | Collector | func (t *TimeCounter) Collector(metric string) Collector {
return CollectorFunc(func() []*datapoint.Datapoint {
dur := time.Duration(atomic.LoadInt64(&t.NsBarrier)).String()
return []*datapoint.Datapoint{
CumulativeP(metric, map[string]string{"range": "above", "time": dur}, &t.Above),
CumulativeP(metric, map... | go | func (t *TimeCounter) Collector(metric string) Collector {
return CollectorFunc(func() []*datapoint.Datapoint {
dur := time.Duration(atomic.LoadInt64(&t.NsBarrier)).String()
return []*datapoint.Datapoint{
CumulativeP(metric, map[string]string{"range": "above", "time": dur}, &t.Above),
CumulativeP(metric, map... | [
"func",
"(",
"t",
"*",
"TimeCounter",
")",
"Collector",
"(",
"metric",
"string",
")",
"Collector",
"{",
"return",
"CollectorFunc",
"(",
"func",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"dur",
":=",
"time",
".",
"Duration",
"(",
"ato... | // Collector returns a datapoint collector for this time counter that uses the given metric name. | [
"Collector",
"returns",
"a",
"datapoint",
"collector",
"for",
"this",
"time",
"counter",
"that",
"uses",
"the",
"given",
"metric",
"name",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/timerange.go#L27-L35 |
140,825 | signalfx/golib | datapoint/datapoint.go | UnmarshalJSON | func (dp *Datapoint) UnmarshalJSON(b []byte) error {
var m jsonDatapoint
dec := json.NewDecoder(bytes.NewBuffer(b))
dec.UseNumber()
if err := dec.Decode(&m); err != nil {
return errors.Annotatef(err, "JSON decoding of byte array %v failed", b)
}
switch t := m.Value.(type) {
case string:
dp.Value = NewStringV... | go | func (dp *Datapoint) UnmarshalJSON(b []byte) error {
var m jsonDatapoint
dec := json.NewDecoder(bytes.NewBuffer(b))
dec.UseNumber()
if err := dec.Decode(&m); err != nil {
return errors.Annotatef(err, "JSON decoding of byte array %v failed", b)
}
switch t := m.Value.(type) {
case string:
dp.Value = NewStringV... | [
"func",
"(",
"dp",
"*",
"Datapoint",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"jsonDatapoint",
"\n",
"dec",
":=",
"json",
".",
"NewDecoder",
"(",
"bytes",
".",
"NewBuffer",
"(",
"b",
")",
")",
"\n",
"dec",
".... | // UnmarshalJSON decodes JSON into a datapoint, creating the correct Value interface types for the
// type of JSON value that was encoded | [
"UnmarshalJSON",
"decodes",
"JSON",
"into",
"a",
"datapoint",
"creating",
"the",
"correct",
"Value",
"interface",
"types",
"for",
"the",
"type",
"of",
"JSON",
"value",
"that",
"was",
"encoded"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/datapoint.go#L65-L87 |
140,826 | signalfx/golib | datapoint/datapoint.go | SetProperty | func (dp *Datapoint) SetProperty(key string, value interface{}) {
if dp.Meta[tsProperty] == nil {
dp.Meta[tsProperty] = make(map[string]interface{}, 1)
}
dp.GetProperties()[key] = value
} | go | func (dp *Datapoint) SetProperty(key string, value interface{}) {
if dp.Meta[tsProperty] == nil {
dp.Meta[tsProperty] = make(map[string]interface{}, 1)
}
dp.GetProperties()[key] = value
} | [
"func",
"(",
"dp",
"*",
"Datapoint",
")",
"SetProperty",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"if",
"dp",
".",
"Meta",
"[",
"tsProperty",
"]",
"==",
"nil",
"{",
"dp",
".",
"Meta",
"[",
"tsProperty",
"]",
"=",
"make",... | // SetProperty sets a property to be used when the time series associated with the datapoint is created | [
"SetProperty",
"sets",
"a",
"property",
"to",
"be",
"used",
"when",
"the",
"time",
"series",
"associated",
"with",
"the",
"datapoint",
"is",
"created"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/datapoint.go#L100-L105 |
140,827 | signalfx/golib | datapoint/datapoint.go | RemoveProperty | func (dp *Datapoint) RemoveProperty(key string) {
if dp.Meta[tsProperty] != nil {
delete(dp.GetProperties(), key)
if len(dp.GetProperties()) == 0 {
delete(dp.Meta, tsProperty)
}
}
} | go | func (dp *Datapoint) RemoveProperty(key string) {
if dp.Meta[tsProperty] != nil {
delete(dp.GetProperties(), key)
if len(dp.GetProperties()) == 0 {
delete(dp.Meta, tsProperty)
}
}
} | [
"func",
"(",
"dp",
"*",
"Datapoint",
")",
"RemoveProperty",
"(",
"key",
"string",
")",
"{",
"if",
"dp",
".",
"Meta",
"[",
"tsProperty",
"]",
"!=",
"nil",
"{",
"delete",
"(",
"dp",
".",
"GetProperties",
"(",
")",
",",
"key",
")",
"\n",
"if",
"len",
... | // RemoveProperty removes a property from the map of properties to be used when the time series associated with the datapoint is created | [
"RemoveProperty",
"removes",
"a",
"property",
"from",
"the",
"map",
"of",
"properties",
"to",
"be",
"used",
"when",
"the",
"time",
"series",
"associated",
"with",
"the",
"datapoint",
"is",
"created"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/datapoint.go#L108-L115 |
140,828 | signalfx/golib | datapoint/datapoint.go | GetProperties | func (dp *Datapoint) GetProperties() map[string]interface{} {
m, ok := dp.Meta[tsProperty].(map[string]interface{})
if !ok {
return nil
}
return m
} | go | func (dp *Datapoint) GetProperties() map[string]interface{} {
m, ok := dp.Meta[tsProperty].(map[string]interface{})
if !ok {
return nil
}
return m
} | [
"func",
"(",
"dp",
"*",
"Datapoint",
")",
"GetProperties",
"(",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"m",
",",
"ok",
":=",
"dp",
".",
"Meta",
"[",
"tsProperty",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}... | // GetProperties gets the map of properties to set when creating the time series associated with the datapoint. nil if no properties are set. | [
"GetProperties",
"gets",
"the",
"map",
"of",
"properties",
"to",
"set",
"when",
"creating",
"the",
"time",
"series",
"associated",
"with",
"the",
"datapoint",
".",
"nil",
"if",
"no",
"properties",
"are",
"set",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/datapoint.go#L118-L124 |
140,829 | signalfx/golib | datapoint/datapoint.go | New | func New(metric string, dimensions map[string]string, value Value, metricType MetricType, timestamp time.Time) *Datapoint {
return NewWithMeta(metric, dimensions, map[interface{}]interface{}{}, value, metricType, timestamp)
} | go | func New(metric string, dimensions map[string]string, value Value, metricType MetricType, timestamp time.Time) *Datapoint {
return NewWithMeta(metric, dimensions, map[interface{}]interface{}{}, value, metricType, timestamp)
} | [
"func",
"New",
"(",
"metric",
"string",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"value",
"Value",
",",
"metricType",
"MetricType",
",",
"timestamp",
"time",
".",
"Time",
")",
"*",
"Datapoint",
"{",
"return",
"NewWithMeta",
"(",
"metric... | // New creates a new datapoint with empty meta data | [
"New",
"creates",
"a",
"new",
"datapoint",
"with",
"empty",
"meta",
"data"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/datapoint.go#L127-L129 |
140,830 | signalfx/golib | datapoint/datapoint.go | NewWithMeta | func NewWithMeta(metric string, dimensions map[string]string, meta map[interface{}]interface{}, value Value, metricType MetricType, timestamp time.Time) *Datapoint {
return &Datapoint{
Metric: metric,
Dimensions: dimensions,
Meta: meta,
Value: value,
MetricType: metricType,
Timestamp: times... | go | func NewWithMeta(metric string, dimensions map[string]string, meta map[interface{}]interface{}, value Value, metricType MetricType, timestamp time.Time) *Datapoint {
return &Datapoint{
Metric: metric,
Dimensions: dimensions,
Meta: meta,
Value: value,
MetricType: metricType,
Timestamp: times... | [
"func",
"NewWithMeta",
"(",
"metric",
"string",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"meta",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
",",
"value",
"Value",
",",
"metricType",
"MetricType",
",",
"timestamp",
... | // NewWithMeta creates a new datapoint with passed metadata | [
"NewWithMeta",
"creates",
"a",
"new",
"datapoint",
"with",
"passed",
"metadata"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/datapoint/datapoint.go#L132-L141 |
140,831 | signalfx/golib | disco/disco.go | BuilderConnector | func BuilderConnector(b *zkplus.Builder) ZkConnCreator {
return ZkConnCreatorFunc(func() (ZkConn, <-chan zk.Event, error) {
return b.BuildDirect()
})
} | go | func BuilderConnector(b *zkplus.Builder) ZkConnCreator {
return ZkConnCreatorFunc(func() (ZkConn, <-chan zk.Event, error) {
return b.BuildDirect()
})
} | [
"func",
"BuilderConnector",
"(",
"b",
"*",
"zkplus",
".",
"Builder",
")",
"ZkConnCreator",
"{",
"return",
"ZkConnCreatorFunc",
"(",
"func",
"(",
")",
"(",
"ZkConn",
",",
"<-",
"chan",
"zk",
".",
"Event",
",",
"error",
")",
"{",
"return",
"b",
".",
"Bui... | // BuilderConnector satisfies the disco zk connect interface for a zkplus.Builder | [
"BuilderConnector",
"satisfies",
"the",
"disco",
"zk",
"connect",
"interface",
"for",
"a",
"zkplus",
".",
"Builder"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L118-L122 |
140,832 | signalfx/golib | disco/disco.go | DeleteAdvertisedServices | func (d *Disco) DeleteAdvertisedServices() {
d.watchedMutex.RLock()
services := make([]string, 0, len(d.myAdvertisedServices))
for s := range d.myAdvertisedServices {
services = append(services, s)
}
d.watchedMutex.RUnlock()
for _, serviceName := range services {
d.DeleteAdvertisedService(serviceName)
}
} | go | func (d *Disco) DeleteAdvertisedServices() {
d.watchedMutex.RLock()
services := make([]string, 0, len(d.myAdvertisedServices))
for s := range d.myAdvertisedServices {
services = append(services, s)
}
d.watchedMutex.RUnlock()
for _, serviceName := range services {
d.DeleteAdvertisedService(serviceName)
}
} | [
"func",
"(",
"d",
"*",
"Disco",
")",
"DeleteAdvertisedServices",
"(",
")",
"{",
"d",
".",
"watchedMutex",
".",
"RLock",
"(",
")",
"\n",
"services",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"d",
".",
"myAdvertisedServices",
")... | // DeleteAdvertisedServices deletes all advertised services | [
"DeleteAdvertisedServices",
"deletes",
"all",
"advertised",
"services"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L243-L253 |
140,833 | signalfx/golib | disco/disco.go | DeleteAdvertisedService | func (d *Disco) DeleteAdvertisedService(serviceName string) {
l := log.NewContext(d.stateLog).With(logkey.DiscoService, serviceName)
servicePath := d.servicePath(serviceName)
exists, stat, _, err := d.zkConn.ExistsW(servicePath)
if err == nil && exists {
d.watchedMutex.Lock()
defer d.watchedMutex.Unlock()
l.L... | go | func (d *Disco) DeleteAdvertisedService(serviceName string) {
l := log.NewContext(d.stateLog).With(logkey.DiscoService, serviceName)
servicePath := d.servicePath(serviceName)
exists, stat, _, err := d.zkConn.ExistsW(servicePath)
if err == nil && exists {
d.watchedMutex.Lock()
defer d.watchedMutex.Unlock()
l.L... | [
"func",
"(",
"d",
"*",
"Disco",
")",
"DeleteAdvertisedService",
"(",
"serviceName",
"string",
")",
"{",
"l",
":=",
"log",
".",
"NewContext",
"(",
"d",
".",
"stateLog",
")",
".",
"With",
"(",
"logkey",
".",
"DiscoService",
",",
"serviceName",
")",
"\n",
... | // DeleteAdvertisedService deletes a specific advertised service name | [
"DeleteAdvertisedService",
"deletes",
"a",
"specific",
"advertised",
"service",
"name"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L256-L267 |
140,834 | signalfx/golib | disco/disco.go | Close | func (d *Disco) Close() {
d.DeleteAdvertisedServices()
close(d.shouldQuit)
<-d.eventLoopDone
d.zkConn.Close()
} | go | func (d *Disco) Close() {
d.DeleteAdvertisedServices()
close(d.shouldQuit)
<-d.eventLoopDone
d.zkConn.Close()
} | [
"func",
"(",
"d",
"*",
"Disco",
")",
"Close",
"(",
")",
"{",
"d",
".",
"DeleteAdvertisedServices",
"(",
")",
"\n",
"close",
"(",
"d",
".",
"shouldQuit",
")",
"\n",
"<-",
"d",
".",
"eventLoopDone",
"\n",
"d",
".",
"zkConn",
".",
"Close",
"(",
")",
... | // Close any open disco connections making this disco unreliable for future updates | [
"Close",
"any",
"open",
"disco",
"connections",
"making",
"this",
"disco",
"unreliable",
"for",
"future",
"updates"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L270-L275 |
140,835 | signalfx/golib | disco/disco.go | Advertise | func (d *Disco) Advertise(serviceName string, payload interface{}, port uint16) (err error) {
f := d.innerPreable(serviceName, &err)
if f == nil {
return nil
}
// Note: Important to defer after we release the mutex since the chan send could be a blocking
// operation
defer f()
d.watchedMutex.Lock()
defe... | go | func (d *Disco) Advertise(serviceName string, payload interface{}, port uint16) (err error) {
f := d.innerPreable(serviceName, &err)
if f == nil {
return nil
}
// Note: Important to defer after we release the mutex since the chan send could be a blocking
// operation
defer f()
d.watchedMutex.Lock()
defe... | [
"func",
"(",
"d",
"*",
"Disco",
")",
"Advertise",
"(",
"serviceName",
"string",
",",
"payload",
"interface",
"{",
"}",
",",
"port",
"uint16",
")",
"(",
"err",
"error",
")",
"{",
"f",
":=",
"d",
".",
"innerPreable",
"(",
"serviceName",
",",
"&",
"err"... | // Advertise yourself as hosting a service | [
"Advertise",
"yourself",
"as",
"hosting",
"a",
"service"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L379-L400 |
140,836 | signalfx/golib | disco/disco.go | CreatePersistentEphemeralNode | func (d *Disco) CreatePersistentEphemeralNode(path string, payload []byte) (err error) {
f := d.innerPreable(path, &err)
if f == nil {
return nil
}
// Note: Important to defer after we release the mutex since the chan send could be a blocking
// operation
defer f()
d.watchedMutex.Lock()
defer d.watchedM... | go | func (d *Disco) CreatePersistentEphemeralNode(path string, payload []byte) (err error) {
f := d.innerPreable(path, &err)
if f == nil {
return nil
}
// Note: Important to defer after we release the mutex since the chan send could be a blocking
// operation
defer f()
d.watchedMutex.Lock()
defer d.watchedM... | [
"func",
"(",
"d",
"*",
"Disco",
")",
"CreatePersistentEphemeralNode",
"(",
"path",
"string",
",",
"payload",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"f",
":=",
"d",
".",
"innerPreable",
"(",
"path",
",",
"&",
"err",
")",
"\n",
"if",
"... | // CreatePersistentEphemeralNode creates a persistent ephemeral node | [
"CreatePersistentEphemeralNode",
"creates",
"a",
"persistent",
"ephemeral",
"node"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L403-L422 |
140,837 | signalfx/golib | disco/disco.go | Var | func (d *Disco) Var() expvar.Var {
return expvar.Func(func() interface{} {
d.watchedMutex.Lock()
defer d.watchedMutex.Unlock()
ret := make(map[string][]ServiceInstance)
for serviceName, service := range d.watchedServices {
ret[serviceName] = service.ServiceInstances()
}
return ret
})
} | go | func (d *Disco) Var() expvar.Var {
return expvar.Func(func() interface{} {
d.watchedMutex.Lock()
defer d.watchedMutex.Unlock()
ret := make(map[string][]ServiceInstance)
for serviceName, service := range d.watchedServices {
ret[serviceName] = service.ServiceInstances()
}
return ret
})
} | [
"func",
"(",
"d",
"*",
"Disco",
")",
"Var",
"(",
")",
"expvar",
".",
"Var",
"{",
"return",
"expvar",
".",
"Func",
"(",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"d",
".",
"watchedMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"d",
".",
"watc... | // Var returns an expvar variable that shows all the current disco services and the current
// list of endpoints seen for each service | [
"Var",
"returns",
"an",
"expvar",
"variable",
"that",
"shows",
"all",
"the",
"current",
"disco",
"services",
"and",
"the",
"current",
"list",
"of",
"endpoints",
"seen",
"for",
"each",
"service"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L426-L436 |
140,838 | signalfx/golib | disco/disco.go | Services | func (d *Disco) Services(serviceName string) (*Service, error) {
d.watchedMutex.Lock()
defer d.watchedMutex.Unlock()
s, exist := d.watchedServices[serviceName]
if exist {
return s, nil
}
ret := &Service{
name: serviceName,
stateLog: log.NewContext(d.stateLog).With(logkey.DiscoService, serviceName),
}
... | go | func (d *Disco) Services(serviceName string) (*Service, error) {
d.watchedMutex.Lock()
defer d.watchedMutex.Unlock()
s, exist := d.watchedServices[serviceName]
if exist {
return s, nil
}
ret := &Service{
name: serviceName,
stateLog: log.NewContext(d.stateLog).With(logkey.DiscoService, serviceName),
}
... | [
"func",
"(",
"d",
"*",
"Disco",
")",
"Services",
"(",
"serviceName",
"string",
")",
"(",
"*",
"Service",
",",
"error",
")",
"{",
"d",
".",
"watchedMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"d",
".",
"watchedMutex",
".",
"Unlock",
"(",
")",
"\n"... | // Services advertising for serviceName | [
"Services",
"advertising",
"for",
"serviceName"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L439-L457 |
140,839 | signalfx/golib | disco/disco.go | ServiceInstances | func (s *Service) ServiceInstances() []ServiceInstance {
svcs := s.services.Load().([]ServiceInstance)
ret := make([]ServiceInstance, len(svcs))
copy(ret, svcs)
sort.Sort(serviceInstanceList(ret))
return ret
} | go | func (s *Service) ServiceInstances() []ServiceInstance {
svcs := s.services.Load().([]ServiceInstance)
ret := make([]ServiceInstance, len(svcs))
copy(ret, svcs)
sort.Sort(serviceInstanceList(ret))
return ret
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"ServiceInstances",
"(",
")",
"[",
"]",
"ServiceInstance",
"{",
"svcs",
":=",
"s",
".",
"services",
".",
"Load",
"(",
")",
".",
"(",
"[",
"]",
"ServiceInstance",
")",
"\n",
"ret",
":=",
"make",
"(",
"[",
"]",
... | // ServiceInstances that represent instances of this service in your system | [
"ServiceInstances",
"that",
"represent",
"instances",
"of",
"this",
"service",
"in",
"your",
"system"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L474-L480 |
140,840 | signalfx/golib | disco/disco.go | ForceInstances | func (s *Service) ForceInstances(instances []ServiceInstance) {
atomic.StoreInt64(&s.ignoreUpdates, 1)
s.watchLock.Lock()
defer s.watchLock.Unlock()
s.services.Store(instances)
for _, watch := range s.watches {
watch()
}
} | go | func (s *Service) ForceInstances(instances []ServiceInstance) {
atomic.StoreInt64(&s.ignoreUpdates, 1)
s.watchLock.Lock()
defer s.watchLock.Unlock()
s.services.Store(instances)
for _, watch := range s.watches {
watch()
}
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"ForceInstances",
"(",
"instances",
"[",
"]",
"ServiceInstance",
")",
"{",
"atomic",
".",
"StoreInt64",
"(",
"&",
"s",
".",
"ignoreUpdates",
",",
"1",
")",
"\n",
"s",
".",
"watchLock",
".",
"Lock",
"(",
")",
"\n... | // ForceInstances overrides a disco service to have exactly the passed instances forever. Useful
// for debugging. | [
"ForceInstances",
"overrides",
"a",
"disco",
"service",
"to",
"have",
"exactly",
"the",
"passed",
"instances",
"forever",
".",
"Useful",
"for",
"debugging",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L484-L492 |
140,841 | signalfx/golib | disco/disco.go | Watch | func (s *Service) Watch(watch ChangeWatch) {
s.watchLock.Lock()
defer s.watchLock.Unlock()
s.watches = append(s.watches, watch)
} | go | func (s *Service) Watch(watch ChangeWatch) {
s.watchLock.Lock()
defer s.watchLock.Unlock()
s.watches = append(s.watches, watch)
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"Watch",
"(",
"watch",
"ChangeWatch",
")",
"{",
"s",
".",
"watchLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"watchLock",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"watches",
"=",
"append",
"(",
"s"... | // Watch for changes to the members of this service | [
"Watch",
"for",
"changes",
"to",
"the",
"members",
"of",
"this",
"service"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/disco/disco.go#L495-L499 |
140,842 | signalfx/golib | log/hierarchy.go | NewHierarchy | func NewHierarchy(defaultLogger Logger) *Hierarchy {
ret := &Hierarchy{}
ret.Set(defaultLogger)
return ret
} | go | func NewHierarchy(defaultLogger Logger) *Hierarchy {
ret := &Hierarchy{}
ret.Set(defaultLogger)
return ret
} | [
"func",
"NewHierarchy",
"(",
"defaultLogger",
"Logger",
")",
"*",
"Hierarchy",
"{",
"ret",
":=",
"&",
"Hierarchy",
"{",
"}",
"\n",
"ret",
".",
"Set",
"(",
"defaultLogger",
")",
"\n",
"return",
"ret",
"\n",
"}"
] | // NewHierarchy creates a Hierarchy type pointer pointing to defaultLogger | [
"NewHierarchy",
"creates",
"a",
"Hierarchy",
"type",
"pointer",
"pointing",
"to",
"defaultLogger"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/hierarchy.go#L29-L33 |
140,843 | signalfx/golib | log/hierarchy.go | Log | func (l *Hierarchy) Log(kvs ...interface{}) {
// Note: Log here messes up "caller" :/
if logger := l.loadLogger(); logger != nil {
logger.Log(kvs...)
}
} | go | func (l *Hierarchy) Log(kvs ...interface{}) {
// Note: Log here messes up "caller" :/
if logger := l.loadLogger(); logger != nil {
logger.Log(kvs...)
}
} | [
"func",
"(",
"l",
"*",
"Hierarchy",
")",
"Log",
"(",
"kvs",
"...",
"interface",
"{",
"}",
")",
"{",
"// Note: Log here messes up \"caller\" :/",
"if",
"logger",
":=",
"l",
".",
"loadLogger",
"(",
")",
";",
"logger",
"!=",
"nil",
"{",
"logger",
".",
"Log"... | // Log calls log of the wrapped logger | [
"Log",
"calls",
"log",
"of",
"the",
"wrapped",
"logger"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/hierarchy.go#L44-L49 |
140,844 | signalfx/golib | log/hierarchy.go | Set | func (l *Hierarchy) Set(logger Logger) {
l.logger.Store(atomicStruct{logger})
} | go | func (l *Hierarchy) Set(logger Logger) {
l.logger.Store(atomicStruct{logger})
} | [
"func",
"(",
"l",
"*",
"Hierarchy",
")",
"Set",
"(",
"logger",
"Logger",
")",
"{",
"l",
".",
"logger",
".",
"Store",
"(",
"atomicStruct",
"{",
"logger",
"}",
")",
"\n",
"}"
] | // Set atomically changes where this logger logs to | [
"Set",
"atomically",
"changes",
"where",
"this",
"logger",
"logs",
"to"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/hierarchy.go#L69-L71 |
140,845 | signalfx/golib | distconf/str.go | Update | func (s *strConf) Update(newValue []byte) error {
s.mutex.Lock()
defer s.mutex.Unlock()
oldValue := s.currentVal.Load().(string)
if newValue == nil {
s.currentVal.Store(s.defaultVal)
} else {
s.currentVal.Store(string(newValue))
}
if oldValue != s.Get() {
for _, w := range s.watches {
w(&s.Str, oldValue... | go | func (s *strConf) Update(newValue []byte) error {
s.mutex.Lock()
defer s.mutex.Unlock()
oldValue := s.currentVal.Load().(string)
if newValue == nil {
s.currentVal.Store(s.defaultVal)
} else {
s.currentVal.Store(string(newValue))
}
if oldValue != s.Get() {
for _, w := range s.watches {
w(&s.Str, oldValue... | [
"func",
"(",
"s",
"*",
"strConf",
")",
"Update",
"(",
"newValue",
"[",
"]",
"byte",
")",
"error",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"oldValue",
":=",
"s",
".",
"curre... | // Update the contents of Str to the new value | [
"Update",
"the",
"contents",
"of",
"Str",
"to",
"the",
"new",
"value"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/str.go#L26-L41 |
140,846 | signalfx/golib | boltcycle/boltcycle.go | AtomicClone | func (s *Stats) AtomicClone() Stats {
return Stats{
TotalItemsRecopied: atomic.LoadInt64(&s.TotalItemsRecopied),
TotalItemsAsyncPut: atomic.LoadInt64(&s.TotalItemsAsyncPut),
RecopyTransactionCount: atomic.LoadInt64(&s.RecopyTransactionCount),
TotalItemsDeletedDuringRecopy: atomic.L... | go | func (s *Stats) AtomicClone() Stats {
return Stats{
TotalItemsRecopied: atomic.LoadInt64(&s.TotalItemsRecopied),
TotalItemsAsyncPut: atomic.LoadInt64(&s.TotalItemsAsyncPut),
RecopyTransactionCount: atomic.LoadInt64(&s.RecopyTransactionCount),
TotalItemsDeletedDuringRecopy: atomic.L... | [
"func",
"(",
"s",
"*",
"Stats",
")",
"AtomicClone",
"(",
")",
"Stats",
"{",
"return",
"Stats",
"{",
"TotalItemsRecopied",
":",
"atomic",
".",
"LoadInt64",
"(",
"&",
"s",
".",
"TotalItemsRecopied",
")",
",",
"TotalItemsAsyncPut",
":",
"atomic",
".",
"LoadIn... | // AtomicClone creates a new stats with somewhat atomically | [
"AtomicClone",
"creates",
"a",
"new",
"stats",
"with",
"somewhat",
"atomically"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/boltcycle/boltcycle.go#L63-L77 |
140,847 | signalfx/golib | boltcycle/boltcycle.go | New | func New(db *bolt.DB, optionalParameters ...DBConfiguration) (*CycleDB, error) {
ret := &CycleDB{
db: db,
bucketTimesIn: defaultBucketName,
minNumOldBuckets: 2,
maxBatchSize: 1000,
readMovementBacklog: 10000,
cursorDelete: func(c *bolt.Cursor) error {
return c.Delete()
... | go | func New(db *bolt.DB, optionalParameters ...DBConfiguration) (*CycleDB, error) {
ret := &CycleDB{
db: db,
bucketTimesIn: defaultBucketName,
minNumOldBuckets: 2,
maxBatchSize: 1000,
readMovementBacklog: 10000,
cursorDelete: func(c *bolt.Cursor) error {
return c.Delete()
... | [
"func",
"New",
"(",
"db",
"*",
"bolt",
".",
"DB",
",",
"optionalParameters",
"...",
"DBConfiguration",
")",
"(",
"*",
"CycleDB",
",",
"error",
")",
"{",
"ret",
":=",
"&",
"CycleDB",
"{",
"db",
":",
"db",
",",
"bucketTimesIn",
":",
"defaultBucketName",
... | // New creates a CycleDB to use a bolt database that cycles minNumOldBuckets buckets | [
"New",
"creates",
"a",
"CycleDB",
"to",
"use",
"a",
"bolt",
"database",
"that",
"cycles",
"minNumOldBuckets",
"buckets"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/boltcycle/boltcycle.go#L131-L156 |
140,848 | signalfx/golib | boltcycle/boltcycle.go | Close | func (c *CycleDB) Close() error {
if !c.db.IsReadOnly() {
close(c.readMovements)
}
c.wg.Wait()
return c.db.Close()
} | go | func (c *CycleDB) Close() error {
if !c.db.IsReadOnly() {
close(c.readMovements)
}
c.wg.Wait()
return c.db.Close()
} | [
"func",
"(",
"c",
"*",
"CycleDB",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"!",
"c",
".",
"db",
".",
"IsReadOnly",
"(",
")",
"{",
"close",
"(",
"c",
".",
"readMovements",
")",
"\n",
"}",
"\n",
"c",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
... | // Close ends the goroutine that moves read items to the latest bucket and now closes the DB itself... | [
"Close",
"ends",
"the",
"goroutine",
"that",
"moves",
"read",
"items",
"to",
"the",
"latest",
"bucket",
"and",
"now",
"closes",
"the",
"DB",
"itself",
"..."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/boltcycle/boltcycle.go#L167-L173 |
140,849 | signalfx/golib | boltcycle/boltcycle.go | VerifyCompressed | func (c *CycleDB) VerifyCompressed() error {
return c.db.View(func(tx *bolt.Tx) error {
bucket := tx.Bucket(c.bucketTimesIn)
if bucket == nil {
return errUnableToFindRootBucket
}
ch, err := createHeapFunc(bucket)
if err != nil {
return errors.Annotate(err, "unable to create heap during compressed veri... | go | func (c *CycleDB) VerifyCompressed() error {
return c.db.View(func(tx *bolt.Tx) error {
bucket := tx.Bucket(c.bucketTimesIn)
if bucket == nil {
return errUnableToFindRootBucket
}
ch, err := createHeapFunc(bucket)
if err != nil {
return errors.Annotate(err, "unable to create heap during compressed veri... | [
"func",
"(",
"c",
"*",
"CycleDB",
")",
"VerifyCompressed",
"(",
")",
"error",
"{",
"return",
"c",
".",
"db",
".",
"View",
"(",
"func",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
")",
"error",
"{",
"bucket",
":=",
"tx",
".",
"Bucket",
"(",
"c",
".",
"bu... | // VerifyCompressed checks that no key is repeated in the database | [
"VerifyCompressed",
"checks",
"that",
"no",
"key",
"is",
"repeated",
"in",
"the",
"database"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/boltcycle/boltcycle.go#L293-L306 |
140,850 | signalfx/golib | web/bucketreqcounter.go | Wrap | func (m *BucketRequestCounter) Wrap(next http.Handler) http.Handler {
f := func(w http.ResponseWriter, r *http.Request) {
m.ServeHTTP(w, r, next)
}
return http.HandlerFunc(f)
} | go | func (m *BucketRequestCounter) Wrap(next http.Handler) http.Handler {
f := func(w http.ResponseWriter, r *http.Request) {
m.ServeHTTP(w, r, next)
}
return http.HandlerFunc(f)
} | [
"func",
"(",
"m",
"*",
"BucketRequestCounter",
")",
"Wrap",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"f",
":=",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"m",
"."... | // Wrap returns a handler that forwards calls to next and counts the calls forwarded | [
"Wrap",
"returns",
"a",
"handler",
"that",
"forwards",
"calls",
"to",
"next",
"and",
"counts",
"the",
"calls",
"forwarded"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/web/bucketreqcounter.go#L22-L27 |
140,851 | signalfx/golib | web/bucketreqcounter.go | Datapoints | func (m *BucketRequestCounter) Datapoints() []*datapoint.Datapoint {
dps := m.Bucket.Datapoints()
return append(dps,
sfxclient.Gauge(m.Bucket.MetricName+".active_connections", m.Bucket.Dimensions, atomic.LoadInt64(&m.ActiveConnections)),
)
} | go | func (m *BucketRequestCounter) Datapoints() []*datapoint.Datapoint {
dps := m.Bucket.Datapoints()
return append(dps,
sfxclient.Gauge(m.Bucket.MetricName+".active_connections", m.Bucket.Dimensions, atomic.LoadInt64(&m.ActiveConnections)),
)
} | [
"func",
"(",
"m",
"*",
"BucketRequestCounter",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"dps",
":=",
"m",
".",
"Bucket",
".",
"Datapoints",
"(",
")",
"\n",
"return",
"append",
"(",
"dps",
",",
"sfxclient",
".",
... | // Datapoints returns active connections plus wrapped bucket stats | [
"Datapoints",
"returns",
"active",
"connections",
"plus",
"wrapped",
"bucket",
"stats"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/web/bucketreqcounter.go#L42-L47 |
140,852 | signalfx/golib | distconf/mem.go | Mem | func Mem() ReaderWriter {
return &memConfig{
vals: make(map[string][]byte),
watches: make(map[string][]backingCallbackFunction),
}
} | go | func Mem() ReaderWriter {
return &memConfig{
vals: make(map[string][]byte),
watches: make(map[string][]backingCallbackFunction),
}
} | [
"func",
"Mem",
"(",
")",
"ReaderWriter",
"{",
"return",
"&",
"memConfig",
"{",
"vals",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
")",
",",
"watches",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"backingCallbackFunction... | // Mem creates a memory config | [
"Mem",
"creates",
"a",
"memory",
"config"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/mem.go#L51-L56 |
140,853 | signalfx/golib | sfxclient/multitokensink.go | getHTTPStatusCode | func getHTTPStatusCode(status *tokenStatus, err error) *tokenStatus {
if err == nil {
status.status = http.StatusOK
} else {
if obj, ok := err.(SFXAPIError); ok {
status.status = obj.StatusCode
}
}
return status
} | go | func getHTTPStatusCode(status *tokenStatus, err error) *tokenStatus {
if err == nil {
status.status = http.StatusOK
} else {
if obj, ok := err.(SFXAPIError); ok {
status.status = obj.StatusCode
}
}
return status
} | [
"func",
"getHTTPStatusCode",
"(",
"status",
"*",
"tokenStatus",
",",
"err",
"error",
")",
"*",
"tokenStatus",
"{",
"if",
"err",
"==",
"nil",
"{",
"status",
".",
"status",
"=",
"http",
".",
"StatusOK",
"\n",
"}",
"else",
"{",
"if",
"obj",
",",
"ok",
"... | // grabs the http status code from an error if it is an SFXAPIError and assigns to the tokenStatus | [
"grabs",
"the",
"http",
"status",
"code",
"from",
"an",
"error",
"if",
"it",
"is",
"an",
"SFXAPIError",
"and",
"assigns",
"to",
"the",
"tokenStatus"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L52-L61 |
140,854 | signalfx/golib | sfxclient/multitokensink.go | Datapoints | func (a *AsyncTokenStatusCounter) Datapoints() (dps []*datapoint.Datapoint) {
var request bool
returnDatapoints := make(chan []*datapoint.Datapoint)
defer close(returnDatapoints)
for {
select {
case <-a.stop:
return
case dps = <-returnDatapoints: // listen on the newly created channel for datapoints
ret... | go | func (a *AsyncTokenStatusCounter) Datapoints() (dps []*datapoint.Datapoint) {
var request bool
returnDatapoints := make(chan []*datapoint.Datapoint)
defer close(returnDatapoints)
for {
select {
case <-a.stop:
return
case dps = <-returnDatapoints: // listen on the newly created channel for datapoints
ret... | [
"func",
"(",
"a",
"*",
"AsyncTokenStatusCounter",
")",
"Datapoints",
"(",
")",
"(",
"dps",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"{",
"var",
"request",
"bool",
"\n",
"returnDatapoints",
":=",
"make",
"(",
"chan",
"[",
"]",
"*",
"datapoint",
... | // Datapoints returns datapoints for each token and status | [
"Datapoints",
"returns",
"datapoints",
"for",
"each",
"token",
"and",
"status"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L102-L119 |
140,855 | signalfx/golib | sfxclient/multitokensink.go | Increment | func (a *AsyncTokenStatusCounter) Increment(status *tokenStatus) {
select {
case <-a.stop: // check if the counter has been stopped
return
default:
select {
case a.input <- status:
default:
}
}
} | go | func (a *AsyncTokenStatusCounter) Increment(status *tokenStatus) {
select {
case <-a.stop: // check if the counter has been stopped
return
default:
select {
case a.input <- status:
default:
}
}
} | [
"func",
"(",
"a",
"*",
"AsyncTokenStatusCounter",
")",
"Increment",
"(",
"status",
"*",
"tokenStatus",
")",
"{",
"select",
"{",
"case",
"<-",
"a",
".",
"stop",
":",
"// check if the counter has been stopped",
"return",
"\n",
"default",
":",
"select",
"{",
"cas... | // Increment adds a tokenStatus object to the counter | [
"Increment",
"adds",
"a",
"tokenStatus",
"object",
"to",
"the",
"counter"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L122-L132 |
140,856 | signalfx/golib | sfxclient/multitokensink.go | NewAsyncTokenStatusCounter | func NewAsyncTokenStatusCounter(name string, buffer int, numWorkers int64, defaultDims map[string]string) *AsyncTokenStatusCounter {
a := &AsyncTokenStatusCounter{
name: name,
dataStore: map[string]map[int]int64{},
input: make(chan *tokenStatus, int64(buffer)*numWorkers),
stop:... | go | func NewAsyncTokenStatusCounter(name string, buffer int, numWorkers int64, defaultDims map[string]string) *AsyncTokenStatusCounter {
a := &AsyncTokenStatusCounter{
name: name,
dataStore: map[string]map[int]int64{},
input: make(chan *tokenStatus, int64(buffer)*numWorkers),
stop:... | [
"func",
"NewAsyncTokenStatusCounter",
"(",
"name",
"string",
",",
"buffer",
"int",
",",
"numWorkers",
"int64",
",",
"defaultDims",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"AsyncTokenStatusCounter",
"{",
"a",
":=",
"&",
"AsyncTokenStatusCounter",
"{",
"nam... | // NewAsyncTokenStatusCounter returns a structure for counting occurences of http statuses by token | [
"NewAsyncTokenStatusCounter",
"returns",
"a",
"structure",
"for",
"counting",
"occurences",
"of",
"http",
"statuses",
"by",
"token"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L135-L158 |
140,857 | signalfx/golib | sfxclient/multitokensink.go | newWorker | func newWorker(errorHandler func(error) error, closing chan bool, done chan bool) *worker {
w := &worker{
lock: &sync.Mutex{},
sink: NewHTTPSink(),
errorHandler: errorHandler,
closing: closing,
done: done,
}
return w
} | go | func newWorker(errorHandler func(error) error, closing chan bool, done chan bool) *worker {
w := &worker{
lock: &sync.Mutex{},
sink: NewHTTPSink(),
errorHandler: errorHandler,
closing: closing,
done: done,
}
return w
} | [
"func",
"newWorker",
"(",
"errorHandler",
"func",
"(",
"error",
")",
"error",
",",
"closing",
"chan",
"bool",
",",
"done",
"chan",
"bool",
")",
"*",
"worker",
"{",
"w",
":=",
"&",
"worker",
"{",
"lock",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
","... | // returns a new instance of worker with an configured emission pipeline | [
"returns",
"a",
"new",
"instance",
"of",
"worker",
"with",
"an",
"configured",
"emission",
"pipeline"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L170-L180 |
140,858 | signalfx/golib | sfxclient/multitokensink.go | newBuffer | func (w *spanWorker) newBuffer() {
for {
select {
// check if the sink is closing and return if so
// reading from a.closing will only return a value if the a.closing channel is closed
// nothing should ever write into it
case <-w.closing:
// signal that the worker is done
w.done <- true
return
ca... | go | func (w *spanWorker) newBuffer() {
for {
select {
// check if the sink is closing and return if so
// reading from a.closing will only return a value if the a.closing channel is closed
// nothing should ever write into it
case <-w.closing:
// signal that the worker is done
w.done <- true
return
ca... | [
"func",
"(",
"w",
"*",
"spanWorker",
")",
"newBuffer",
"(",
")",
"{",
"for",
"{",
"select",
"{",
"// check if the sink is closing and return if so",
"// reading from a.closing will only return a value if the a.closing channel is closed",
"// nothing should ever write into it",
"cas... | // newBuffer buffers datapoints and traces in the pipeline for the duration specified during Startup | [
"newBuffer",
"buffers",
"datapoints",
"and",
"traces",
"in",
"the",
"pipeline",
"for",
"the",
"duration",
"specified",
"during",
"Startup"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L499-L514 |
140,859 | signalfx/golib | sfxclient/multitokensink.go | Datapoints | func (a *AsyncMultiTokenSink) Datapoints() (dps []*datapoint.Datapoint) {
dps = append(dps, Gauge("total_datapoints_buffered", a.stats.DefaultDimensions, atomic.LoadInt64(&a.stats.TotalDatapointsBuffered)))
dps = append(dps, Gauge("total_events_buffered", a.stats.DefaultDimensions, atomic.LoadInt64(&a.stats.TotalEven... | go | func (a *AsyncMultiTokenSink) Datapoints() (dps []*datapoint.Datapoint) {
dps = append(dps, Gauge("total_datapoints_buffered", a.stats.DefaultDimensions, atomic.LoadInt64(&a.stats.TotalDatapointsBuffered)))
dps = append(dps, Gauge("total_events_buffered", a.stats.DefaultDimensions, atomic.LoadInt64(&a.stats.TotalEven... | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"Datapoints",
"(",
")",
"(",
"dps",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"{",
"dps",
"=",
"append",
"(",
"dps",
",",
"Gauge",
"(",
"\"",
"\"",
",",
"a",
".",
"stats",
".",
"DefaultDim... | // Datapoints returns a set of datapoints about the sink | [
"Datapoints",
"returns",
"a",
"set",
"of",
"datapoints",
"about",
"the",
"sink"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L601-L613 |
140,860 | signalfx/golib | sfxclient/multitokensink.go | getChannel | func (a *AsyncMultiTokenSink) getChannel(input string, size int) (workerID int64, err error) {
a.lock.Lock()
if a.Hasher != nil {
a.Hasher.Reset()
_, _ = a.Hasher.Write([]byte(input))
if size > 0 {
workerID = int64(a.Hasher.Sum32()) % int64(size)
} else {
err = fmt.Errorf("no available workers")
}
} ... | go | func (a *AsyncMultiTokenSink) getChannel(input string, size int) (workerID int64, err error) {
a.lock.Lock()
if a.Hasher != nil {
a.Hasher.Reset()
_, _ = a.Hasher.Write([]byte(input))
if size > 0 {
workerID = int64(a.Hasher.Sum32()) % int64(size)
} else {
err = fmt.Errorf("no available workers")
}
} ... | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"getChannel",
"(",
"input",
"string",
",",
"size",
"int",
")",
"(",
"workerID",
"int64",
",",
"err",
"error",
")",
"{",
"a",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"if",
"a",
".",
"Hasher",
"!="... | // getChannel hashes the string to one of the channels and returns the integer position of the channel | [
"getChannel",
"hashes",
"the",
"string",
"to",
"one",
"of",
"the",
"channels",
"and",
"returns",
"the",
"integer",
"position",
"of",
"the",
"channel"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L616-L631 |
140,861 | signalfx/golib | sfxclient/multitokensink.go | AddDatapointsWithToken | func (a *AsyncMultiTokenSink) AddDatapointsWithToken(token string, datapoints []*datapoint.Datapoint) (err error) {
var channelID int64
if channelID, err = a.getChannel(token, len(a.dpChannels)); err == nil {
var worker = a.dpChannels[channelID]
_ = atomic.AddInt64(&a.dpBuffered, int64(len(datapoints)))
var m =... | go | func (a *AsyncMultiTokenSink) AddDatapointsWithToken(token string, datapoints []*datapoint.Datapoint) (err error) {
var channelID int64
if channelID, err = a.getChannel(token, len(a.dpChannels)); err == nil {
var worker = a.dpChannels[channelID]
_ = atomic.AddInt64(&a.dpBuffered, int64(len(datapoints)))
var m =... | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"AddDatapointsWithToken",
"(",
"token",
"string",
",",
"datapoints",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"(",
"err",
"error",
")",
"{",
"var",
"channelID",
"int64",
"\n",
"if",
"channelID",
... | // AddDatapointsWithToken emits a list of datapoints using a supplied token | [
"AddDatapointsWithToken",
"emits",
"a",
"list",
"of",
"datapoints",
"using",
"a",
"supplied",
"token"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L634-L661 |
140,862 | signalfx/golib | sfxclient/multitokensink.go | AddDatapoints | func (a *AsyncMultiTokenSink) AddDatapoints(ctx context.Context, datapoints []*datapoint.Datapoint) (err error) {
if token := ctx.Value(TokenCtxKey); token != nil {
err = a.AddDatapointsWithToken(token.(string), datapoints)
} else {
err = fmt.Errorf("no value was found on the context with key '%s'", TokenCtxKey)
... | go | func (a *AsyncMultiTokenSink) AddDatapoints(ctx context.Context, datapoints []*datapoint.Datapoint) (err error) {
if token := ctx.Value(TokenCtxKey); token != nil {
err = a.AddDatapointsWithToken(token.(string), datapoints)
} else {
err = fmt.Errorf("no value was found on the context with key '%s'", TokenCtxKey)
... | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"AddDatapoints",
"(",
"ctx",
"context",
".",
"Context",
",",
"datapoints",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"(",
"err",
"error",
")",
"{",
"if",
"token",
":=",
"ctx",
".",
"Value",
"(... | // AddDatapoints add datepoints to the multitoken sync using a context that has the TokenCtxKey | [
"AddDatapoints",
"add",
"datepoints",
"to",
"the",
"multitoken",
"sync",
"using",
"a",
"context",
"that",
"has",
"the",
"TokenCtxKey"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L664-L671 |
140,863 | signalfx/golib | sfxclient/multitokensink.go | AddEventsWithToken | func (a *AsyncMultiTokenSink) AddEventsWithToken(token string, events []*event.Event) (err error) {
var channelID int64
if channelID, err = a.getChannel(token, len(a.evChannels)); err == nil {
var worker = a.evChannels[channelID]
_ = atomic.AddInt64(&a.evBuffered, int64(len(events)))
var m = &evMsg{
token: t... | go | func (a *AsyncMultiTokenSink) AddEventsWithToken(token string, events []*event.Event) (err error) {
var channelID int64
if channelID, err = a.getChannel(token, len(a.evChannels)); err == nil {
var worker = a.evChannels[channelID]
_ = atomic.AddInt64(&a.evBuffered, int64(len(events)))
var m = &evMsg{
token: t... | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"AddEventsWithToken",
"(",
"token",
"string",
",",
"events",
"[",
"]",
"*",
"event",
".",
"Event",
")",
"(",
"err",
"error",
")",
"{",
"var",
"channelID",
"int64",
"\n",
"if",
"channelID",
",",
"err",
... | // AddEventsWithToken emits a list of events using a supplied token | [
"AddEventsWithToken",
"emits",
"a",
"list",
"of",
"events",
"using",
"a",
"supplied",
"token"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L674-L702 |
140,864 | signalfx/golib | sfxclient/multitokensink.go | AddEvents | func (a *AsyncMultiTokenSink) AddEvents(ctx context.Context, events []*event.Event) (err error) {
if token := ctx.Value(TokenCtxKey); token != nil {
err = a.AddEventsWithToken(token.(string), events)
} else {
err = fmt.Errorf("no value was found on the context with key '%s'", TokenCtxKey)
}
return
} | go | func (a *AsyncMultiTokenSink) AddEvents(ctx context.Context, events []*event.Event) (err error) {
if token := ctx.Value(TokenCtxKey); token != nil {
err = a.AddEventsWithToken(token.(string), events)
} else {
err = fmt.Errorf("no value was found on the context with key '%s'", TokenCtxKey)
}
return
} | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"AddEvents",
"(",
"ctx",
"context",
".",
"Context",
",",
"events",
"[",
"]",
"*",
"event",
".",
"Event",
")",
"(",
"err",
"error",
")",
"{",
"if",
"token",
":=",
"ctx",
".",
"Value",
"(",
"TokenCtxKe... | // AddEvents add datepoints to the multitoken sync using a context that has the TokenCtxKey | [
"AddEvents",
"add",
"datepoints",
"to",
"the",
"multitoken",
"sync",
"using",
"a",
"context",
"that",
"has",
"the",
"TokenCtxKey"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L705-L712 |
140,865 | signalfx/golib | sfxclient/multitokensink.go | AddSpansWithToken | func (a *AsyncMultiTokenSink) AddSpansWithToken(token string, spans []*trace.Span) (err error) {
var channelID int64
if channelID, err = a.getChannel(token, len(a.evChannels)); err == nil {
var worker = a.spanChannels[channelID]
_ = atomic.AddInt64(&a.spansBuffered, int64(len(spans)))
var m = &spanMsg{
token... | go | func (a *AsyncMultiTokenSink) AddSpansWithToken(token string, spans []*trace.Span) (err error) {
var channelID int64
if channelID, err = a.getChannel(token, len(a.evChannels)); err == nil {
var worker = a.spanChannels[channelID]
_ = atomic.AddInt64(&a.spansBuffered, int64(len(spans)))
var m = &spanMsg{
token... | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"AddSpansWithToken",
"(",
"token",
"string",
",",
"spans",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"(",
"err",
"error",
")",
"{",
"var",
"channelID",
"int64",
"\n",
"if",
"channelID",
",",
"err",
"="... | // AddSpansWithToken emits a list of events using a supplied token | [
"AddSpansWithToken",
"emits",
"a",
"list",
"of",
"events",
"using",
"a",
"supplied",
"token"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L715-L743 |
140,866 | signalfx/golib | sfxclient/multitokensink.go | AddSpans | func (a *AsyncMultiTokenSink) AddSpans(ctx context.Context, spans []*trace.Span) (err error) {
if token := ctx.Value(TokenCtxKey); token != nil {
err = a.AddSpansWithToken(token.(string), spans)
} else {
err = fmt.Errorf("no value was found on the context with key '%s'", TokenCtxKey)
}
return
} | go | func (a *AsyncMultiTokenSink) AddSpans(ctx context.Context, spans []*trace.Span) (err error) {
if token := ctx.Value(TokenCtxKey); token != nil {
err = a.AddSpansWithToken(token.(string), spans)
} else {
err = fmt.Errorf("no value was found on the context with key '%s'", TokenCtxKey)
}
return
} | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"AddSpans",
"(",
"ctx",
"context",
".",
"Context",
",",
"spans",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"(",
"err",
"error",
")",
"{",
"if",
"token",
":=",
"ctx",
".",
"Value",
"(",
"TokenCtxKey",... | // AddSpans add datepoints to the multitoken sync using a context that has the TokenCtxKey | [
"AddSpans",
"add",
"datepoints",
"to",
"the",
"multitoken",
"sync",
"using",
"a",
"context",
"that",
"has",
"the",
"TokenCtxKey"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L746-L753 |
140,867 | signalfx/golib | sfxclient/multitokensink.go | closeWorkers | func (a *AsyncMultiTokenSink) closeWorkers() (datapointsDropped, eventsDropped, spansDropped int64) {
// signal to all workers that the sink is closing
close(a.closing)
// timer to timeout close operations
timeout := time.After(a.ShutdownTimeout)
done:
for {
if atomic.LoadInt64(&a.stats.NumberOfEventWorkers) =... | go | func (a *AsyncMultiTokenSink) closeWorkers() (datapointsDropped, eventsDropped, spansDropped int64) {
// signal to all workers that the sink is closing
close(a.closing)
// timer to timeout close operations
timeout := time.After(a.ShutdownTimeout)
done:
for {
if atomic.LoadInt64(&a.stats.NumberOfEventWorkers) =... | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"closeWorkers",
"(",
")",
"(",
"datapointsDropped",
",",
"eventsDropped",
",",
"spansDropped",
"int64",
")",
"{",
"// signal to all workers that the sink is closing",
"close",
"(",
"a",
".",
"closing",
")",
"\n\n",
... | // close workers and get the number of datapoints and events dropped if they do not close cleanly | [
"close",
"workers",
"and",
"get",
"the",
"number",
"of",
"datapoints",
"and",
"events",
"dropped",
"if",
"they",
"do",
"not",
"close",
"cleanly"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L756-L785 |
140,868 | signalfx/golib | sfxclient/multitokensink.go | Close | func (a *AsyncMultiTokenSink) Close() (err error) {
// close the workers and collect the number of datapoints and events still buffered
datapointsDropped, eventsDropped, spansDropped := a.closeWorkers()
// if something didn't close cleanly return an appropriate error message
if atomic.LoadInt64(&a.stats.NumberOfDa... | go | func (a *AsyncMultiTokenSink) Close() (err error) {
// close the workers and collect the number of datapoints and events still buffered
datapointsDropped, eventsDropped, spansDropped := a.closeWorkers()
// if something didn't close cleanly return an appropriate error message
if atomic.LoadInt64(&a.stats.NumberOfDa... | [
"func",
"(",
"a",
"*",
"AsyncMultiTokenSink",
")",
"Close",
"(",
")",
"(",
"err",
"error",
")",
"{",
"// close the workers and collect the number of datapoints and events still buffered",
"datapointsDropped",
",",
"eventsDropped",
",",
"spansDropped",
":=",
"a",
".",
"c... | // Close stops the existing workers and prevents additional datapoints from being added
// if a ShutdownTimeout is set on the sink, it will be used as a timeout for closing the sink
// the default timeout is 5 seconds | [
"Close",
"stops",
"the",
"existing",
"workers",
"and",
"prevents",
"additional",
"datapoints",
"from",
"being",
"added",
"if",
"a",
"ShutdownTimeout",
"is",
"set",
"on",
"the",
"sink",
"it",
"will",
"be",
"used",
"as",
"a",
"timeout",
"for",
"closing",
"the"... | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L790-L800 |
140,869 | signalfx/golib | sfxclient/multitokensink.go | NewAsyncMultiTokenSink | func NewAsyncMultiTokenSink(numChannels int64, numDrainingThreads int64, buffer int, batchSize int, DatapointEndpoint, EventEndpoint, TraceEndpoint, userAgent string, httpClient func() *http.Client, errorHandler func(error) error, maxRetry int) *AsyncMultiTokenSink {
a := &AsyncMultiTokenSink{
ShutdownTimeout: time.... | go | func NewAsyncMultiTokenSink(numChannels int64, numDrainingThreads int64, buffer int, batchSize int, DatapointEndpoint, EventEndpoint, TraceEndpoint, userAgent string, httpClient func() *http.Client, errorHandler func(error) error, maxRetry int) *AsyncMultiTokenSink {
a := &AsyncMultiTokenSink{
ShutdownTimeout: time.... | [
"func",
"NewAsyncMultiTokenSink",
"(",
"numChannels",
"int64",
",",
"numDrainingThreads",
"int64",
",",
"buffer",
"int",
",",
"batchSize",
"int",
",",
"DatapointEndpoint",
",",
"EventEndpoint",
",",
"TraceEndpoint",
",",
"userAgent",
"string",
",",
"httpClient",
"fu... | // NewAsyncMultiTokenSink returns a sink that asynchronously emits datapoints with different tokens | [
"NewAsyncMultiTokenSink",
"returns",
"a",
"sink",
"that",
"asynchronously",
"emits",
"datapoints",
"with",
"different",
"tokens"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/multitokensink.go#L891-L930 |
140,870 | signalfx/golib | eventcounter/eventcounter.go | New | func New(now time.Time, duration time.Duration) EventCounter {
return EventCounter{
startingTime: now,
nsSinceStart: 0,
eventDuration: duration,
eventsThisPeriod: 0,
}
} | go | func New(now time.Time, duration time.Duration) EventCounter {
return EventCounter{
startingTime: now,
nsSinceStart: 0,
eventDuration: duration,
eventsThisPeriod: 0,
}
} | [
"func",
"New",
"(",
"now",
"time",
".",
"Time",
",",
"duration",
"time",
".",
"Duration",
")",
"EventCounter",
"{",
"return",
"EventCounter",
"{",
"startingTime",
":",
"now",
",",
"nsSinceStart",
":",
"0",
",",
"eventDuration",
":",
"duration",
",",
"event... | // New returns a new EventCounter object that resets event counts per duration. | [
"New",
"returns",
"a",
"new",
"EventCounter",
"object",
"that",
"resets",
"event",
"counts",
"per",
"duration",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/eventcounter/eventcounter.go#L19-L26 |
140,871 | signalfx/golib | eventcounter/eventcounter.go | Event | func (a *EventCounter) Event(now time.Time) int64 {
return a.Events(now, 1)
} | go | func (a *EventCounter) Event(now time.Time) int64 {
return a.Events(now, 1)
} | [
"func",
"(",
"a",
"*",
"EventCounter",
")",
"Event",
"(",
"now",
"time",
".",
"Time",
")",
"int64",
"{",
"return",
"a",
".",
"Events",
"(",
"now",
",",
"1",
")",
"\n",
"}"
] | // Event returns the number of events in the time period now. Note, now should be >= the
// last event threshold. Also, we avoid any loops with compare and swap atomics because we're ok
// being off a few items as long as we're generally accurate and fast. | [
"Event",
"returns",
"the",
"number",
"of",
"events",
"in",
"the",
"time",
"period",
"now",
".",
"Note",
"now",
"should",
"be",
">",
"=",
"the",
"last",
"event",
"threshold",
".",
"Also",
"we",
"avoid",
"any",
"loops",
"with",
"compare",
"and",
"swap",
... | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/eventcounter/eventcounter.go#L31-L33 |
140,872 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | Error | func (s *Map) Error() string {
bytes, err := json.Marshal(s)
resp := "Unable to format Map"
if err == nil {
resp = string(bytes)
}
return resp
} | go | func (s *Map) Error() string {
bytes, err := json.Marshal(s)
resp := "Unable to format Map"
if err == nil {
resp = string(bytes)
}
return resp
} | [
"func",
"(",
"s",
"*",
"Map",
")",
"Error",
"(",
")",
"string",
"{",
"bytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"s",
")",
"\n",
"resp",
":=",
"\"",
"\"",
"\n",
"if",
"err",
"==",
"nil",
"{",
"resp",
"=",
"string",
"(",
"bytes",
"... | // Error returns a json representation of the Map | [
"Error",
"returns",
"a",
"json",
"representation",
"of",
"the",
"Map"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L30-L37 |
140,873 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | Add | func (s *Map) Add(errType string, id string) {
if strings.ToLower(errType) == OK {
s.Valid++
} else {
if s.Invalid == nil {
s.Invalid = make(map[string][]string)
}
s.Invalid[errType] = append(s.Invalid[errType], id)
}
} | go | func (s *Map) Add(errType string, id string) {
if strings.ToLower(errType) == OK {
s.Valid++
} else {
if s.Invalid == nil {
s.Invalid = make(map[string][]string)
}
s.Invalid[errType] = append(s.Invalid[errType], id)
}
} | [
"func",
"(",
"s",
"*",
"Map",
")",
"Add",
"(",
"errType",
"string",
",",
"id",
"string",
")",
"{",
"if",
"strings",
".",
"ToLower",
"(",
"errType",
")",
"==",
"OK",
"{",
"s",
".",
"Valid",
"++",
"\n",
"}",
"else",
"{",
"if",
"s",
".",
"Invalid"... | // Add a error trace id | [
"Add",
"a",
"error",
"trace",
"id"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L40-L49 |
140,874 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | FromBytes | func FromBytes(body []byte) *Map {
var spanFilter Map
if err := json.Unmarshal(body, &spanFilter); err != nil {
return nil
}
return &spanFilter
} | go | func FromBytes(body []byte) *Map {
var spanFilter Map
if err := json.Unmarshal(body, &spanFilter); err != nil {
return nil
}
return &spanFilter
} | [
"func",
"FromBytes",
"(",
"body",
"[",
"]",
"byte",
")",
"*",
"Map",
"{",
"var",
"spanFilter",
"Map",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"spanFilter",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
... | // FromBytes returns a Map or an error | [
"FromBytes",
"returns",
"a",
"Map",
"or",
"an",
"error"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L52-L58 |
140,875 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | ReturnInvalidOrError | func ReturnInvalidOrError(body []byte) error {
if sf := FromBytes(body); sf != nil {
if sf.CheckInvalid() {
return sf
}
return nil
}
return errors.New(string(body))
} | go | func ReturnInvalidOrError(body []byte) error {
if sf := FromBytes(body); sf != nil {
if sf.CheckInvalid() {
return sf
}
return nil
}
return errors.New(string(body))
} | [
"func",
"ReturnInvalidOrError",
"(",
"body",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"sf",
":=",
"FromBytes",
"(",
"body",
")",
";",
"sf",
"!=",
"nil",
"{",
"if",
"sf",
".",
"CheckInvalid",
"(",
")",
"{",
"return",
"sf",
"\n",
"}",
"\n",
"return... | // ReturnInvalidOrError returns nil for a valid SpanFilter, an invalid SpanFilter or an error containing the bytes | [
"ReturnInvalidOrError",
"returns",
"nil",
"for",
"a",
"valid",
"SpanFilter",
"an",
"invalid",
"SpanFilter",
"or",
"an",
"error",
"containing",
"the",
"bytes"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L61-L69 |
140,876 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | WithSpanFilterContext | func WithSpanFilterContext(ctx context.Context, sf *Map) context.Context {
return context.WithValue(ctx, spanFailures, sf)
} | go | func WithSpanFilterContext(ctx context.Context, sf *Map) context.Context {
return context.WithValue(ctx, spanFailures, sf)
} | [
"func",
"WithSpanFilterContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"sf",
"*",
"Map",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"spanFailures",
",",
"sf",
")",
"\n",
"}"
] | // WithSpanFilterContext gives you a request with the Map set | [
"WithSpanFilterContext",
"gives",
"you",
"a",
"request",
"with",
"the",
"Map",
"set"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L78-L80 |
140,877 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | GetSpanFilterMapOrNew | func GetSpanFilterMapOrNew(ctx context.Context) (context.Context, *Map) {
v := ctx.Value(spanFailures)
if v != nil {
failMap := v.(*Map)
return ctx, failMap
}
failMap := &Map{}
return context.WithValue(ctx, spanFailures, failMap), failMap
} | go | func GetSpanFilterMapOrNew(ctx context.Context) (context.Context, *Map) {
v := ctx.Value(spanFailures)
if v != nil {
failMap := v.(*Map)
return ctx, failMap
}
failMap := &Map{}
return context.WithValue(ctx, spanFailures, failMap), failMap
} | [
"func",
"GetSpanFilterMapOrNew",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"context",
".",
"Context",
",",
"*",
"Map",
")",
"{",
"v",
":=",
"ctx",
".",
"Value",
"(",
"spanFailures",
")",
"\n",
"if",
"v",
"!=",
"nil",
"{",
"failMap",
":=",
"v",... | // GetSpanFilterMapOrNew is a target for spanumsink.SinkFunc to be turned into a spanumsink.Sink | [
"GetSpanFilterMapOrNew",
"is",
"a",
"target",
"for",
"spanumsink",
".",
"SinkFunc",
"to",
"be",
"turned",
"into",
"a",
"spanumsink",
".",
"Sink"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L83-L91 |
140,878 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | GetSpanFilterMapFromContext | func GetSpanFilterMapFromContext(ctx context.Context) error {
v := ctx.Value(spanFailures)
if v != nil {
failMap := v.(*Map)
return failMap
}
return emptySpanFilter
} | go | func GetSpanFilterMapFromContext(ctx context.Context) error {
v := ctx.Value(spanFailures)
if v != nil {
failMap := v.(*Map)
return failMap
}
return emptySpanFilter
} | [
"func",
"GetSpanFilterMapFromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"v",
":=",
"ctx",
".",
"Value",
"(",
"spanFailures",
")",
"\n",
"if",
"v",
"!=",
"nil",
"{",
"failMap",
":=",
"v",
".",
"(",
"*",
"Map",
")",
"\n",
"retu... | // GetSpanFilterMapFromContext is a target for spanumsink.SinkFunc to be turned into a spanumsink.Sink | [
"GetSpanFilterMapFromContext",
"is",
"a",
"target",
"for",
"spanumsink",
".",
"SinkFunc",
"to",
"be",
"turned",
"into",
"a",
"spanumsink",
".",
"Sink"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L94-L101 |
140,879 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | IsMap | func IsMap(err error) bool {
if err != nil {
switch err.(type) {
case *Map:
return true
}
}
return false
} | go | func IsMap(err error) bool {
if err != nil {
switch err.(type) {
case *Map:
return true
}
}
return false
} | [
"func",
"IsMap",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"!=",
"nil",
"{",
"switch",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Map",
":",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsMap returns whether an error is an instance of Map | [
"IsMap",
"returns",
"whether",
"an",
"error",
"is",
"an",
"instance",
"of",
"Map"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L104-L112 |
140,880 | signalfx/golib | sfxclient/spanfilter/spanfilter.go | IsInvalid | func IsInvalid(err error) bool {
if err != nil {
switch err.(type) {
case *Map:
return err.(*Map).CheckInvalid()
}
}
return err != nil
} | go | func IsInvalid(err error) bool {
if err != nil {
switch err.(type) {
case *Map:
return err.(*Map).CheckInvalid()
}
}
return err != nil
} | [
"func",
"IsInvalid",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"!=",
"nil",
"{",
"switch",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Map",
":",
"return",
"err",
".",
"(",
"*",
"Map",
")",
".",
"CheckInvalid",
"(",
")",
"\n",
"}... | // IsInvalid returns false if it's a Map with no invalid entries or nil, else true | [
"IsInvalid",
"returns",
"false",
"if",
"it",
"s",
"a",
"Map",
"with",
"no",
"invalid",
"entries",
"or",
"nil",
"else",
"true"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/spanfilter/spanfilter.go#L115-L123 |
140,881 | signalfx/golib | distconf/zk.go | Get | func (back *zkConfig) Get(key string) ([]byte, error) {
back.rootLogger.Log(logkey.ZkMethod, "get", logkey.ZkPath, key)
pathToFetch := back.configPath(key)
bytes, _, _, err := back.conn.GetW(pathToFetch)
if err != nil {
if err == zk.ErrNoNode {
return nil, nil
}
return nil, errors.Annotatef(err, "cannot lo... | go | func (back *zkConfig) Get(key string) ([]byte, error) {
back.rootLogger.Log(logkey.ZkMethod, "get", logkey.ZkPath, key)
pathToFetch := back.configPath(key)
bytes, _, _, err := back.conn.GetW(pathToFetch)
if err != nil {
if err == zk.ErrNoNode {
return nil, nil
}
return nil, errors.Annotatef(err, "cannot lo... | [
"func",
"(",
"back",
"*",
"zkConfig",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"back",
".",
"rootLogger",
".",
"Log",
"(",
"logkey",
".",
"ZkMethod",
",",
"\"",
"\"",
",",
"logkey",
".",
"ZkPath",
",",... | // Get returns the config value from zookeeper | [
"Get",
"returns",
"the",
"config",
"value",
"from",
"zookeeper"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/zk.go#L115-L126 |
140,882 | signalfx/golib | distconf/zk.go | Zk | func Zk(zkConnector ZkConnector, conf *ZkConfig) (ReaderWriter, error) {
conf = pointer.FillDefaultFrom(conf, DefaultZkConfig).(*ZkConfig)
ret := &zkConfig{
rootLogger: log.NewContext(conf.Logger).With(logkey.DistconfBacking, "zk"),
shouldQuit: make(chan struct{}),
callbacks: callbackMap{
callbacks: make(map... | go | func Zk(zkConnector ZkConnector, conf *ZkConfig) (ReaderWriter, error) {
conf = pointer.FillDefaultFrom(conf, DefaultZkConfig).(*ZkConfig)
ret := &zkConfig{
rootLogger: log.NewContext(conf.Logger).With(logkey.DistconfBacking, "zk"),
shouldQuit: make(chan struct{}),
callbacks: callbackMap{
callbacks: make(map... | [
"func",
"Zk",
"(",
"zkConnector",
"ZkConnector",
",",
"conf",
"*",
"ZkConfig",
")",
"(",
"ReaderWriter",
",",
"error",
")",
"{",
"conf",
"=",
"pointer",
".",
"FillDefaultFrom",
"(",
"conf",
",",
"DefaultZkConfig",
")",
".",
"(",
"*",
"ZkConfig",
")",
"\n... | // Zk creates a zookeeper readable backing | [
"Zk",
"creates",
"a",
"zookeeper",
"readable",
"backing"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/zk.go#L266-L285 |
140,883 | signalfx/golib | sfxclient/datapointcreation.go | Gauge | func Gauge(metricName string, dimensions map[string]string, val int64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewIntValue(val), datapoint.Gauge, time.Time{})
} | go | func Gauge(metricName string, dimensions map[string]string, val int64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewIntValue(val), datapoint.Gauge, time.Time{})
} | [
"func",
"Gauge",
"(",
"metricName",
"string",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"val",
"int64",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"datapoint",
".",
"New",
"(",
"metricName",
",",
"dimensions",
",",
"datapoin... | // Gauge creates a SignalFx gauge for integer values. | [
"Gauge",
"creates",
"a",
"SignalFx",
"gauge",
"for",
"integer",
"values",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/datapointcreation.go#L11-L13 |
140,884 | signalfx/golib | sfxclient/datapointcreation.go | GaugeF | func GaugeF(metricName string, dimensions map[string]string, val float64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewFloatValue(val), datapoint.Gauge, time.Time{})
} | go | func GaugeF(metricName string, dimensions map[string]string, val float64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewFloatValue(val), datapoint.Gauge, time.Time{})
} | [
"func",
"GaugeF",
"(",
"metricName",
"string",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"val",
"float64",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"datapoint",
".",
"New",
"(",
"metricName",
",",
"dimensions",
",",
"datap... | // GaugeF creates a SignalFx gauge for floating point values. | [
"GaugeF",
"creates",
"a",
"SignalFx",
"gauge",
"for",
"floating",
"point",
"values",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/datapointcreation.go#L16-L18 |
140,885 | signalfx/golib | sfxclient/datapointcreation.go | Cumulative | func Cumulative(metricName string, dimensions map[string]string, val int64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewIntValue(val), datapoint.Counter, time.Time{})
} | go | func Cumulative(metricName string, dimensions map[string]string, val int64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewIntValue(val), datapoint.Counter, time.Time{})
} | [
"func",
"Cumulative",
"(",
"metricName",
"string",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"val",
"int64",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"datapoint",
".",
"New",
"(",
"metricName",
",",
"dimensions",
",",
"dat... | // Cumulative creates a SignalFx cumulative counter for integer values. | [
"Cumulative",
"creates",
"a",
"SignalFx",
"cumulative",
"counter",
"for",
"integer",
"values",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/datapointcreation.go#L21-L23 |
140,886 | signalfx/golib | sfxclient/datapointcreation.go | CumulativeF | func CumulativeF(metricName string, dimensions map[string]string, val float64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewFloatValue(val), datapoint.Counter, time.Time{})
} | go | func CumulativeF(metricName string, dimensions map[string]string, val float64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewFloatValue(val), datapoint.Counter, time.Time{})
} | [
"func",
"CumulativeF",
"(",
"metricName",
"string",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"val",
"float64",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"datapoint",
".",
"New",
"(",
"metricName",
",",
"dimensions",
",",
"... | // CumulativeF creates a SignalFx cumulative counter for float values. | [
"CumulativeF",
"creates",
"a",
"SignalFx",
"cumulative",
"counter",
"for",
"float",
"values",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/datapointcreation.go#L26-L28 |
140,887 | signalfx/golib | sfxclient/datapointcreation.go | CumulativeP | func CumulativeP(metricName string, dimensions map[string]string, val *int64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewIntValue(atomic.LoadInt64(val)), datapoint.Counter, time.Time{})
} | go | func CumulativeP(metricName string, dimensions map[string]string, val *int64) *datapoint.Datapoint {
return datapoint.New(metricName, dimensions, datapoint.NewIntValue(atomic.LoadInt64(val)), datapoint.Counter, time.Time{})
} | [
"func",
"CumulativeP",
"(",
"metricName",
"string",
",",
"dimensions",
"map",
"[",
"string",
"]",
"string",
",",
"val",
"*",
"int64",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"datapoint",
".",
"New",
"(",
"metricName",
",",
"dimensions",
","... | // CumulativeP creates a SignalFx cumulative counter for integer values from a pointer that is loaded atomically. | [
"CumulativeP",
"creates",
"a",
"SignalFx",
"cumulative",
"counter",
"for",
"integer",
"values",
"from",
"a",
"pointer",
"that",
"is",
"loaded",
"atomically",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/sfxclient/datapointcreation.go#L31-L33 |
140,888 | signalfx/golib | distconf/distconf.go | New | func New(readers []Reader) *Distconf {
return &Distconf{
Logger: DefaultLogger,
readers: readers,
registeredVars: make(map[string]*registeredVariableTracker),
distInfos: make(map[string]DistInfo),
}
} | go | func New(readers []Reader) *Distconf {
return &Distconf{
Logger: DefaultLogger,
readers: readers,
registeredVars: make(map[string]*registeredVariableTracker),
distInfos: make(map[string]DistInfo),
}
} | [
"func",
"New",
"(",
"readers",
"[",
"]",
"Reader",
")",
"*",
"Distconf",
"{",
"return",
"&",
"Distconf",
"{",
"Logger",
":",
"DefaultLogger",
",",
"readers",
":",
"readers",
",",
"registeredVars",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"regi... | // New creates a Distconf from a list of backing readers | [
"New",
"creates",
"a",
"Distconf",
"from",
"a",
"list",
"of",
"backing",
"readers"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/distconf.go#L37-L44 |
140,889 | signalfx/golib | distconf/distconf.go | Var | func (c *Distconf) Var() expvar.Var {
return expvar.Func(func() interface{} {
c.varsMutex.Lock()
defer c.varsMutex.Unlock()
m := make(map[string]interface{}, len(c.registeredVars))
for name, v := range c.registeredVars {
m[name] = v.distvar.GenericGet()
}
return m
})
} | go | func (c *Distconf) Var() expvar.Var {
return expvar.Func(func() interface{} {
c.varsMutex.Lock()
defer c.varsMutex.Unlock()
m := make(map[string]interface{}, len(c.registeredVars))
for name, v := range c.registeredVars {
m[name] = v.distvar.GenericGet()
}
return m
})
} | [
"func",
"(",
"c",
"*",
"Distconf",
")",
"Var",
"(",
")",
"expvar",
".",
"Var",
"{",
"return",
"expvar",
".",
"Func",
"(",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"c",
".",
"varsMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"vars... | // Var returns an expvar variable that shows all the current configuration variables and their
// current value | [
"Var",
"returns",
"an",
"expvar",
"variable",
"that",
"shows",
"all",
"the",
"current",
"configuration",
"variables",
"and",
"their",
"current",
"value"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/distconf.go#L103-L114 |
140,890 | signalfx/golib | distconf/distconf.go | Info | func (c *Distconf) Info() expvar.Var {
return expvar.Func(func() interface{} {
c.infoMutex.RLock()
defer c.infoMutex.RUnlock()
m := make(map[string]DistInfo, len(c.distInfos))
for k, i := range c.distInfos {
v, ok := c.registeredVars[k]
if ok {
v := DistInfo{
File: i.File,
Line: ... | go | func (c *Distconf) Info() expvar.Var {
return expvar.Func(func() interface{} {
c.infoMutex.RLock()
defer c.infoMutex.RUnlock()
m := make(map[string]DistInfo, len(c.distInfos))
for k, i := range c.distInfos {
v, ok := c.registeredVars[k]
if ok {
v := DistInfo{
File: i.File,
Line: ... | [
"func",
"(",
"c",
"*",
"Distconf",
")",
"Info",
"(",
")",
"expvar",
".",
"Var",
"{",
"return",
"expvar",
".",
"Func",
"(",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"c",
".",
"infoMutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"in... | // Info returns an expvar variable that shows the information for all configuration variables.
// Information consist of file, line, default value and type of variable. | [
"Info",
"returns",
"an",
"expvar",
"variable",
"that",
"shows",
"the",
"information",
"for",
"all",
"configuration",
"variables",
".",
"Information",
"consist",
"of",
"file",
"line",
"default",
"value",
"and",
"type",
"of",
"variable",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/distconf.go#L118-L138 |
140,891 | signalfx/golib | distconf/distconf.go | Int | func (c *Distconf) Int(key string, defaultVal int64) *Int {
c.grabInfo(key)
s := &intConf{
defaultVal: defaultVal,
Int: Int{
currentVal: defaultVal,
},
}
// Note: in race conditions 's' may not be the thing actually returned
ret, okCast := c.createOrGet(key, s).(*intConf)
if !okCast {
c.Logger.Log(logk... | go | func (c *Distconf) Int(key string, defaultVal int64) *Int {
c.grabInfo(key)
s := &intConf{
defaultVal: defaultVal,
Int: Int{
currentVal: defaultVal,
},
}
// Note: in race conditions 's' may not be the thing actually returned
ret, okCast := c.createOrGet(key, s).(*intConf)
if !okCast {
c.Logger.Log(logk... | [
"func",
"(",
"c",
"*",
"Distconf",
")",
"Int",
"(",
"key",
"string",
",",
"defaultVal",
"int64",
")",
"*",
"Int",
"{",
"c",
".",
"grabInfo",
"(",
"key",
")",
"\n",
"s",
":=",
"&",
"intConf",
"{",
"defaultVal",
":",
"defaultVal",
",",
"Int",
":",
... | // Int object that can be referenced to get integer values from a backing config | [
"Int",
"object",
"that",
"can",
"be",
"referenced",
"to",
"get",
"integer",
"values",
"from",
"a",
"backing",
"config"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/distconf.go#L141-L156 |
140,892 | signalfx/golib | distconf/distconf.go | Float | func (c *Distconf) Float(key string, defaultVal float64) *Float {
c.grabInfo(key)
s := &floatConf{
defaultVal: defaultVal,
Float: Float{
currentVal: math.Float64bits(defaultVal),
},
}
// Note: in race conditions 's' may not be the thing actually returned
ret, okCast := c.createOrGet(key, s).(*floatConf)
... | go | func (c *Distconf) Float(key string, defaultVal float64) *Float {
c.grabInfo(key)
s := &floatConf{
defaultVal: defaultVal,
Float: Float{
currentVal: math.Float64bits(defaultVal),
},
}
// Note: in race conditions 's' may not be the thing actually returned
ret, okCast := c.createOrGet(key, s).(*floatConf)
... | [
"func",
"(",
"c",
"*",
"Distconf",
")",
"Float",
"(",
"key",
"string",
",",
"defaultVal",
"float64",
")",
"*",
"Float",
"{",
"c",
".",
"grabInfo",
"(",
"key",
")",
"\n",
"s",
":=",
"&",
"floatConf",
"{",
"defaultVal",
":",
"defaultVal",
",",
"Float",... | // Float object that can be referenced to get float values from a backing config | [
"Float",
"object",
"that",
"can",
"be",
"referenced",
"to",
"get",
"float",
"values",
"from",
"a",
"backing",
"config"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/distconf.go#L159-L174 |
140,893 | signalfx/golib | distconf/distconf.go | Str | func (c *Distconf) Str(key string, defaultVal string) *Str {
c.grabInfo(key)
s := &strConf{
defaultVal: defaultVal,
}
s.currentVal.Store(defaultVal)
// Note: in race conditions 's' may not be the thing actually returned
ret, okCast := c.createOrGet(key, s).(*strConf)
if !okCast {
c.Logger.Log(logkey.Distconf... | go | func (c *Distconf) Str(key string, defaultVal string) *Str {
c.grabInfo(key)
s := &strConf{
defaultVal: defaultVal,
}
s.currentVal.Store(defaultVal)
// Note: in race conditions 's' may not be the thing actually returned
ret, okCast := c.createOrGet(key, s).(*strConf)
if !okCast {
c.Logger.Log(logkey.Distconf... | [
"func",
"(",
"c",
"*",
"Distconf",
")",
"Str",
"(",
"key",
"string",
",",
"defaultVal",
"string",
")",
"*",
"Str",
"{",
"c",
".",
"grabInfo",
"(",
"key",
")",
"\n",
"s",
":=",
"&",
"strConf",
"{",
"defaultVal",
":",
"defaultVal",
",",
"}",
"\n",
... | // Str object that can be referenced to get string values from a backing config | [
"Str",
"object",
"that",
"can",
"be",
"referenced",
"to",
"get",
"string",
"values",
"from",
"a",
"backing",
"config"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/distconf.go#L177-L190 |
140,894 | signalfx/golib | distconf/distconf.go | Bool | func (c *Distconf) Bool(key string, defaultVal bool) *Bool {
c.grabInfo(key)
var defautlAsInt int32
if defaultVal {
defautlAsInt = 1
} else {
defautlAsInt = 0
}
s := &boolConf{
defaultVal: defautlAsInt,
Bool: Bool{
currentVal: defautlAsInt,
},
}
// Note: in race conditions 's' may not be the thing... | go | func (c *Distconf) Bool(key string, defaultVal bool) *Bool {
c.grabInfo(key)
var defautlAsInt int32
if defaultVal {
defautlAsInt = 1
} else {
defautlAsInt = 0
}
s := &boolConf{
defaultVal: defautlAsInt,
Bool: Bool{
currentVal: defautlAsInt,
},
}
// Note: in race conditions 's' may not be the thing... | [
"func",
"(",
"c",
"*",
"Distconf",
")",
"Bool",
"(",
"key",
"string",
",",
"defaultVal",
"bool",
")",
"*",
"Bool",
"{",
"c",
".",
"grabInfo",
"(",
"key",
")",
"\n",
"var",
"defautlAsInt",
"int32",
"\n",
"if",
"defaultVal",
"{",
"defautlAsInt",
"=",
"... | // Bool object that can be referenced to get boolean values from a backing config | [
"Bool",
"object",
"that",
"can",
"be",
"referenced",
"to",
"get",
"boolean",
"values",
"from",
"a",
"backing",
"config"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/distconf.go#L193-L215 |
140,895 | signalfx/golib | distconf/distconf.go | Close | func (c *Distconf) Close() {
c.varsMutex.Lock()
defer c.varsMutex.Unlock()
for _, backing := range c.readers {
backing.Close()
}
} | go | func (c *Distconf) Close() {
c.varsMutex.Lock()
defer c.varsMutex.Unlock()
for _, backing := range c.readers {
backing.Close()
}
} | [
"func",
"(",
"c",
"*",
"Distconf",
")",
"Close",
"(",
")",
"{",
"c",
".",
"varsMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"varsMutex",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"backing",
":=",
"range",
"c",
".",
"readers",
"... | // Close this config framework's readers. Config variable results are undefined after this call. | [
"Close",
"this",
"config",
"framework",
"s",
"readers",
".",
"Config",
"variable",
"results",
"are",
"undefined",
"after",
"this",
"call",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/distconf/distconf.go#L237-L243 |
140,896 | signalfx/golib | log/channel.go | NewChannelLogger | func NewChannelLogger(size int, onFull Logger) *ChannelLogger {
return &ChannelLogger{
Out: make(chan []interface{}, size),
Err: make(chan error, size),
OnFull: onFull,
}
} | go | func NewChannelLogger(size int, onFull Logger) *ChannelLogger {
return &ChannelLogger{
Out: make(chan []interface{}, size),
Err: make(chan error, size),
OnFull: onFull,
}
} | [
"func",
"NewChannelLogger",
"(",
"size",
"int",
",",
"onFull",
"Logger",
")",
"*",
"ChannelLogger",
"{",
"return",
"&",
"ChannelLogger",
"{",
"Out",
":",
"make",
"(",
"chan",
"[",
"]",
"interface",
"{",
"}",
",",
"size",
")",
",",
"Err",
":",
"make",
... | // NewChannelLogger creates a ChannelLogger for channels with size buffer | [
"NewChannelLogger",
"creates",
"a",
"ChannelLogger",
"for",
"channels",
"with",
"size",
"buffer"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/channel.go#L12-L18 |
140,897 | signalfx/golib | log/channel.go | ErrorLogger | func (c *ChannelLogger) ErrorLogger(err error) Logger {
c.Err <- err
return c
} | go | func (c *ChannelLogger) ErrorLogger(err error) Logger {
c.Err <- err
return c
} | [
"func",
"(",
"c",
"*",
"ChannelLogger",
")",
"ErrorLogger",
"(",
"err",
"error",
")",
"Logger",
"{",
"c",
".",
"Err",
"<-",
"err",
"\n",
"return",
"c",
"\n",
"}"
] | // ErrorLogger adds the err to ChannelLogger's buffer and returns itself | [
"ErrorLogger",
"adds",
"the",
"err",
"to",
"ChannelLogger",
"s",
"buffer",
"and",
"returns",
"itself"
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/channel.go#L33-L36 |
140,898 | signalfx/golib | log/channel.go | Log | func (c *ChannelLogger) Log(kvs ...interface{}) {
if c.OnFull != nil {
c.logNonBlocking(kvs...)
return
}
c.logBlocking(kvs...)
} | go | func (c *ChannelLogger) Log(kvs ...interface{}) {
if c.OnFull != nil {
c.logNonBlocking(kvs...)
return
}
c.logBlocking(kvs...)
} | [
"func",
"(",
"c",
"*",
"ChannelLogger",
")",
"Log",
"(",
"kvs",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"c",
".",
"OnFull",
"!=",
"nil",
"{",
"c",
".",
"logNonBlocking",
"(",
"kvs",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"c",
".",
"... | // Log blocks adding kvs to it's buffer. If OnFull is not nil, it does not block. | [
"Log",
"blocks",
"adding",
"kvs",
"to",
"it",
"s",
"buffer",
".",
"If",
"OnFull",
"is",
"not",
"nil",
"it",
"does",
"not",
"block",
"."
] | 5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef | https://github.com/signalfx/golib/blob/5aa9ff46dab65ebcaaf1cee9c32b7d3e761ac6ef/log/channel.go#L39-L45 |
140,899 | go-playground/overalls | overalls.go | walkDirectories | func walkDirectories(path string, walkFunc func(path string, info os.FileInfo) error) error {
seen := make(map[string]bool)
var walkHelper func(path string) error
walkHelper = func(path string) error {
qualifiedPath, err := realpath.Realpath(path)
if err != nil {
return err
}
// Prevent circular links.
... | go | func walkDirectories(path string, walkFunc func(path string, info os.FileInfo) error) error {
seen := make(map[string]bool)
var walkHelper func(path string) error
walkHelper = func(path string) error {
qualifiedPath, err := realpath.Realpath(path)
if err != nil {
return err
}
// Prevent circular links.
... | [
"func",
"walkDirectories",
"(",
"path",
"string",
",",
"walkFunc",
"func",
"(",
"path",
"string",
",",
"info",
"os",
".",
"FileInfo",
")",
"error",
")",
"error",
"{",
"seen",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n\n",
"var",
"... | // walk is like filepath.Walk, but it follows symlinks and only calls walkFunc on directories. | [
"walk",
"is",
"like",
"filepath",
".",
"Walk",
"but",
"it",
"follows",
"symlinks",
"and",
"only",
"calls",
"walkFunc",
"on",
"directories",
"."
] | 22ec1a223b7c9a2e56355bd500b539cba3784238 | https://github.com/go-playground/overalls/blob/22ec1a223b7c9a2e56355bd500b539cba3784238/overalls.go#L291-L338 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.