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 listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
151,200 | uber-go/fx | internal/lifecycle/lifecycle.go | Start | func (l *Lifecycle) Start(ctx context.Context) error {
for _, hook := range l.hooks {
if hook.OnStart != nil {
l.logger.Printf("START\t\t%s()", hook.caller)
if err := hook.OnStart(ctx); err != nil {
return err
}
}
l.numStarted++
}
return nil
} | go | func (l *Lifecycle) Start(ctx context.Context) error {
for _, hook := range l.hooks {
if hook.OnStart != nil {
l.logger.Printf("START\t\t%s()", hook.caller)
if err := hook.OnStart(ctx); err != nil {
return err
}
}
l.numStarted++
}
return nil
} | [
"func",
"(",
"l",
"*",
"Lifecycle",
")",
"Start",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"for",
"_",
",",
"hook",
":=",
"range",
"l",
".",
"hooks",
"{",
"if",
"hook",
".",
"OnStart",
"!=",
"nil",
"{",
"l",
".",
"logger",
".",
... | // Start runs all OnStart hooks, returning immediately if it encounters an
// error. | [
"Start",
"runs",
"all",
"OnStart",
"hooks",
"returning",
"immediately",
"if",
"it",
"encounters",
"an",
"error",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/lifecycle/lifecycle.go#L62-L73 |
151,201 | uber-go/fx | internal/lifecycle/lifecycle.go | Stop | func (l *Lifecycle) Stop(ctx context.Context) error {
var errs []error
// Run backward from last successful OnStart.
for ; l.numStarted > 0; l.numStarted-- {
hook := l.hooks[l.numStarted-1]
if hook.OnStop == nil {
continue
}
l.logger.Printf("STOP\t\t%s()", hook.caller)
if err := hook.OnStop(ctx); err != nil {
// For best-effort cleanup, keep going after errors.
errs = append(errs, err)
}
}
return multierr.Combine(errs...)
} | go | func (l *Lifecycle) Stop(ctx context.Context) error {
var errs []error
// Run backward from last successful OnStart.
for ; l.numStarted > 0; l.numStarted-- {
hook := l.hooks[l.numStarted-1]
if hook.OnStop == nil {
continue
}
l.logger.Printf("STOP\t\t%s()", hook.caller)
if err := hook.OnStop(ctx); err != nil {
// For best-effort cleanup, keep going after errors.
errs = append(errs, err)
}
}
return multierr.Combine(errs...)
} | [
"func",
"(",
"l",
"*",
"Lifecycle",
")",
"Stop",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"var",
"errs",
"[",
"]",
"error",
"\n",
"// Run backward from last successful OnStart.",
"for",
";",
"l",
".",
"numStarted",
">",
"0",
";",
"l",
".... | // Stop runs any OnStop hooks whose OnStart counterpart succeeded. OnStop
// hooks run in reverse order. | [
"Stop",
"runs",
"any",
"OnStop",
"hooks",
"whose",
"OnStart",
"counterpart",
"succeeded",
".",
"OnStop",
"hooks",
"run",
"in",
"reverse",
"order",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/lifecycle/lifecycle.go#L77-L92 |
151,202 | uber-go/fx | internal/fxlog/fxlog.go | PrintProvide | func (l *Logger) PrintProvide(t interface{}) {
for _, rtype := range fxreflect.ReturnTypes(t) {
l.Printf("PROVIDE\t%s <= %s", rtype, fxreflect.FuncName(t))
}
} | go | func (l *Logger) PrintProvide(t interface{}) {
for _, rtype := range fxreflect.ReturnTypes(t) {
l.Printf("PROVIDE\t%s <= %s", rtype, fxreflect.FuncName(t))
}
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"PrintProvide",
"(",
"t",
"interface",
"{",
"}",
")",
"{",
"for",
"_",
",",
"rtype",
":=",
"range",
"fxreflect",
".",
"ReturnTypes",
"(",
"t",
")",
"{",
"l",
".",
"Printf",
"(",
"\"",
"\\t",
"\"",
",",
"rtype... | // PrintProvide logs a type provided into the dig.Container. | [
"PrintProvide",
"logs",
"a",
"type",
"provided",
"into",
"the",
"dig",
".",
"Container",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxlog/fxlog.go#L55-L59 |
151,203 | uber-go/fx | internal/fxlog/fxlog.go | PrintSignal | func (l *Logger) PrintSignal(signal os.Signal) {
l.Printf(strings.ToUpper(signal.String()))
} | go | func (l *Logger) PrintSignal(signal os.Signal) {
l.Printf(strings.ToUpper(signal.String()))
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"PrintSignal",
"(",
"signal",
"os",
".",
"Signal",
")",
"{",
"l",
".",
"Printf",
"(",
"strings",
".",
"ToUpper",
"(",
"signal",
".",
"String",
"(",
")",
")",
")",
"\n",
"}"
] | // PrintSignal logs an os.Signal. | [
"PrintSignal",
"logs",
"an",
"os",
".",
"Signal",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxlog/fxlog.go#L62-L64 |
151,204 | uber-go/fx | internal/fxlog/fxlog.go | Panic | func (l *Logger) Panic(err error) {
l.Printer.Printf(prepend(err.Error()))
panic(err)
} | go | func (l *Logger) Panic(err error) {
l.Printer.Printf(prepend(err.Error()))
panic(err)
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Panic",
"(",
"err",
"error",
")",
"{",
"l",
".",
"Printer",
".",
"Printf",
"(",
"prepend",
"(",
"err",
".",
"Error",
"(",
")",
")",
")",
"\n",
"panic",
"(",
"err",
")",
"\n",
"}"
] | // Panic logs an Fx line then panics. | [
"Panic",
"logs",
"an",
"Fx",
"line",
"then",
"panics",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxlog/fxlog.go#L67-L70 |
151,205 | uber-go/fx | internal/fxlog/fxlog.go | Fatalf | func (l *Logger) Fatalf(format string, v ...interface{}) {
l.Printer.Printf(prepend(format), v...)
_exit()
} | go | func (l *Logger) Fatalf(format string, v ...interface{}) {
l.Printer.Printf(prepend(format), v...)
_exit()
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Fatalf",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"Printer",
".",
"Printf",
"(",
"prepend",
"(",
"format",
")",
",",
"v",
"...",
")",
"\n",
"_exit",
"(",
")",
"\... | // Fatalf logs an Fx line then fatals. | [
"Fatalf",
"logs",
"an",
"Fx",
"line",
"then",
"fatals",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxlog/fxlog.go#L73-L76 |
151,206 | uber-go/fx | internal/fxreflect/fxreflect.go | ReturnTypes | func ReturnTypes(t interface{}) []string {
if reflect.TypeOf(t).Kind() != reflect.Func {
// Invalid provide, will be logged as an error.
return []string{}
}
rtypes := []string{}
ft := reflect.ValueOf(t).Type()
for i := 0; i < ft.NumOut(); i++ {
t := ft.Out(i)
traverseOuts(key{t: t}, func(s string) {
rtypes = append(rtypes, s)
})
}
return rtypes
} | go | func ReturnTypes(t interface{}) []string {
if reflect.TypeOf(t).Kind() != reflect.Func {
// Invalid provide, will be logged as an error.
return []string{}
}
rtypes := []string{}
ft := reflect.ValueOf(t).Type()
for i := 0; i < ft.NumOut(); i++ {
t := ft.Out(i)
traverseOuts(key{t: t}, func(s string) {
rtypes = append(rtypes, s)
})
}
return rtypes
} | [
"func",
"ReturnTypes",
"(",
"t",
"interface",
"{",
"}",
")",
"[",
"]",
"string",
"{",
"if",
"reflect",
".",
"TypeOf",
"(",
"t",
")",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Func",
"{",
"// Invalid provide, will be logged as an error.",
"return",
"[",... | // ReturnTypes takes a func and returns a slice of string'd types. | [
"ReturnTypes",
"takes",
"a",
"func",
"and",
"returns",
"a",
"slice",
"of",
"string",
"d",
"types",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxreflect/fxreflect.go#L38-L56 |
151,207 | uber-go/fx | internal/fxreflect/fxreflect.go | sanitize | func sanitize(function string) string {
// Use the stdlib to un-escape any package import paths which can happen
// in the case of the "dot-git" postfix. Seems like a bug in stdlib =/
if unescaped, err := url.QueryUnescape(function); err == nil {
function = unescaped
}
// strip everything prior to the vendor
return vendorRe.ReplaceAllString(function, "vendor/")
} | go | func sanitize(function string) string {
// Use the stdlib to un-escape any package import paths which can happen
// in the case of the "dot-git" postfix. Seems like a bug in stdlib =/
if unescaped, err := url.QueryUnescape(function); err == nil {
function = unescaped
}
// strip everything prior to the vendor
return vendorRe.ReplaceAllString(function, "vendor/")
} | [
"func",
"sanitize",
"(",
"function",
"string",
")",
"string",
"{",
"// Use the stdlib to un-escape any package import paths which can happen",
"// in the case of the \"dot-git\" postfix. Seems like a bug in stdlib =/",
"if",
"unescaped",
",",
"err",
":=",
"url",
".",
"QueryUnescape... | // sanitize makes the function name suitable for logging display. It removes
// url-encoded elements from the `dot.git` package names and shortens the
// vendored paths. | [
"sanitize",
"makes",
"the",
"function",
"name",
"suitable",
"for",
"logging",
"display",
".",
"It",
"removes",
"url",
"-",
"encoded",
"elements",
"from",
"the",
"dot",
".",
"git",
"package",
"names",
"and",
"shortens",
"the",
"vendored",
"paths",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxreflect/fxreflect.go#L104-L113 |
151,208 | uber-go/fx | internal/fxreflect/fxreflect.go | Caller | func Caller() string {
// Ascend at most 8 frames looking for a caller outside fx.
pcs := make([]uintptr, 8)
// Don't include this frame.
n := runtime.Callers(2, pcs)
if n == 0 {
return "n/a"
}
frames := runtime.CallersFrames(pcs)
for f, more := frames.Next(); more; f, more = frames.Next() {
if shouldIgnoreFrame(f) {
continue
}
return sanitize(f.Function)
}
return "n/a"
} | go | func Caller() string {
// Ascend at most 8 frames looking for a caller outside fx.
pcs := make([]uintptr, 8)
// Don't include this frame.
n := runtime.Callers(2, pcs)
if n == 0 {
return "n/a"
}
frames := runtime.CallersFrames(pcs)
for f, more := frames.Next(); more; f, more = frames.Next() {
if shouldIgnoreFrame(f) {
continue
}
return sanitize(f.Function)
}
return "n/a"
} | [
"func",
"Caller",
"(",
")",
"string",
"{",
"// Ascend at most 8 frames looking for a caller outside fx.",
"pcs",
":=",
"make",
"(",
"[",
"]",
"uintptr",
",",
"8",
")",
"\n\n",
"// Don't include this frame.",
"n",
":=",
"runtime",
".",
"Callers",
"(",
"2",
",",
"... | // Caller returns the formatted calling func name | [
"Caller",
"returns",
"the",
"formatted",
"calling",
"func",
"name"
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxreflect/fxreflect.go#L116-L134 |
151,209 | uber-go/fx | internal/fxreflect/fxreflect.go | FuncName | func FuncName(fn interface{}) string {
fnV := reflect.ValueOf(fn)
if fnV.Kind() != reflect.Func {
return "n/a"
}
function := runtime.FuncForPC(fnV.Pointer()).Name()
return fmt.Sprintf("%s()", sanitize(function))
} | go | func FuncName(fn interface{}) string {
fnV := reflect.ValueOf(fn)
if fnV.Kind() != reflect.Func {
return "n/a"
}
function := runtime.FuncForPC(fnV.Pointer()).Name()
return fmt.Sprintf("%s()", sanitize(function))
} | [
"func",
"FuncName",
"(",
"fn",
"interface",
"{",
"}",
")",
"string",
"{",
"fnV",
":=",
"reflect",
".",
"ValueOf",
"(",
"fn",
")",
"\n",
"if",
"fnV",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Func",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n"... | // FuncName returns a funcs formatted name | [
"FuncName",
"returns",
"a",
"funcs",
"formatted",
"name"
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxreflect/fxreflect.go#L137-L145 |
151,210 | uber-go/fx | internal/fxreflect/fxreflect.go | shouldIgnoreFrame | func shouldIgnoreFrame(f runtime.Frame) bool {
if strings.Contains(f.File, "_test.go") {
return false
}
if strings.Contains(f.File, "go.uber.org/fx") {
return true
}
return false
} | go | func shouldIgnoreFrame(f runtime.Frame) bool {
if strings.Contains(f.File, "_test.go") {
return false
}
if strings.Contains(f.File, "go.uber.org/fx") {
return true
}
return false
} | [
"func",
"shouldIgnoreFrame",
"(",
"f",
"runtime",
".",
"Frame",
")",
"bool",
"{",
"if",
"strings",
".",
"Contains",
"(",
"f",
".",
"File",
",",
"\"",
"\"",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"f",
".... | // Ascend the call stack until we leave the Fx production code. This allows us
// to avoid hard-coding a frame skip, which makes this code work well even
// when it's wrapped. | [
"Ascend",
"the",
"call",
"stack",
"until",
"we",
"leave",
"the",
"Fx",
"production",
"code",
".",
"This",
"allows",
"us",
"to",
"avoid",
"hard",
"-",
"coding",
"a",
"frame",
"skip",
"which",
"makes",
"this",
"code",
"work",
"well",
"even",
"when",
"it",
... | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/fxreflect/fxreflect.go#L155-L163 |
151,211 | uber-go/fx | app.go | Error | func Error(errs ...error) Option {
return optionFunc(func(app *App) {
app.err = multierr.Append(app.err, multierr.Combine(errs...))
})
} | go | func Error(errs ...error) Option {
return optionFunc(func(app *App) {
app.err = multierr.Append(app.err, multierr.Combine(errs...))
})
} | [
"func",
"Error",
"(",
"errs",
"...",
"error",
")",
"Option",
"{",
"return",
"optionFunc",
"(",
"func",
"(",
"app",
"*",
"App",
")",
"{",
"app",
".",
"err",
"=",
"multierr",
".",
"Append",
"(",
"app",
".",
"err",
",",
"multierr",
".",
"Combine",
"("... | // Error registers any number of errors with the application to short-circuit
// startup. If more than one error is given, the errors are combined into a
// single error.
//
// Similar to invocations, errors are applied in order. All Provide and Invoke
// options registered before or after an Error option will not be applied. | [
"Error",
"registers",
"any",
"number",
"of",
"errors",
"with",
"the",
"application",
"to",
"short",
"-",
"circuit",
"startup",
".",
"If",
"more",
"than",
"one",
"error",
"is",
"given",
"the",
"errors",
"are",
"combined",
"into",
"a",
"single",
"error",
"."... | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L149-L153 |
151,212 | uber-go/fx | app.go | StartTimeout | func StartTimeout(v time.Duration) Option {
return optionFunc(func(app *App) {
app.startTimeout = v
})
} | go | func StartTimeout(v time.Duration) Option {
return optionFunc(func(app *App) {
app.startTimeout = v
})
} | [
"func",
"StartTimeout",
"(",
"v",
"time",
".",
"Duration",
")",
"Option",
"{",
"return",
"optionFunc",
"(",
"func",
"(",
"app",
"*",
"App",
")",
"{",
"app",
".",
"startTimeout",
"=",
"v",
"\n",
"}",
")",
"\n",
"}"
] | // StartTimeout changes the application's start timeout. | [
"StartTimeout",
"changes",
"the",
"application",
"s",
"start",
"timeout",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L207-L211 |
151,213 | uber-go/fx | app.go | StopTimeout | func StopTimeout(v time.Duration) Option {
return optionFunc(func(app *App) {
app.stopTimeout = v
})
} | go | func StopTimeout(v time.Duration) Option {
return optionFunc(func(app *App) {
app.stopTimeout = v
})
} | [
"func",
"StopTimeout",
"(",
"v",
"time",
".",
"Duration",
")",
"Option",
"{",
"return",
"optionFunc",
"(",
"func",
"(",
"app",
"*",
"App",
")",
"{",
"app",
".",
"stopTimeout",
"=",
"v",
"\n",
"}",
")",
"\n",
"}"
] | // StopTimeout changes the application's stop timeout. | [
"StopTimeout",
"changes",
"the",
"application",
"s",
"stop",
"timeout",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L214-L218 |
151,214 | uber-go/fx | app.go | Logger | func Logger(p Printer) Option {
return optionFunc(func(app *App) {
app.logger = &fxlog.Logger{Printer: p}
app.lifecycle = &lifecycleWrapper{lifecycle.New(app.logger)}
})
} | go | func Logger(p Printer) Option {
return optionFunc(func(app *App) {
app.logger = &fxlog.Logger{Printer: p}
app.lifecycle = &lifecycleWrapper{lifecycle.New(app.logger)}
})
} | [
"func",
"Logger",
"(",
"p",
"Printer",
")",
"Option",
"{",
"return",
"optionFunc",
"(",
"func",
"(",
"app",
"*",
"App",
")",
"{",
"app",
".",
"logger",
"=",
"&",
"fxlog",
".",
"Logger",
"{",
"Printer",
":",
"p",
"}",
"\n",
"app",
".",
"lifecycle",
... | // Logger redirects the application's log output to the provided printer. | [
"Logger",
"redirects",
"the",
"application",
"s",
"log",
"output",
"to",
"the",
"provided",
"printer",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L227-L232 |
151,215 | uber-go/fx | app.go | New | func New(opts ...Option) *App {
logger := fxlog.New()
lc := &lifecycleWrapper{lifecycle.New(logger)}
app := &App{
container: dig.New(dig.DeferAcyclicVerification()),
lifecycle: lc,
logger: logger,
startTimeout: DefaultTimeout,
stopTimeout: DefaultTimeout,
}
for _, opt := range opts {
opt.apply(app)
}
for _, p := range app.provides {
app.provide(p)
}
app.provide(func() Lifecycle { return app.lifecycle })
app.provide(app.shutdowner)
app.provide(app.dotGraph)
if app.err != nil {
app.logger.Printf("Error after options were applied: %v", app.err)
return app
}
if err := app.executeInvokes(); err != nil {
app.err = err
if dig.CanVisualizeError(err) {
var b bytes.Buffer
dig.Visualize(app.container, &b, dig.VisualizeError(err))
err = errorWithGraph{
graph: b.String(),
err: err,
}
}
errorHandlerList(app.errorHooks).HandleError(err)
}
return app
} | go | func New(opts ...Option) *App {
logger := fxlog.New()
lc := &lifecycleWrapper{lifecycle.New(logger)}
app := &App{
container: dig.New(dig.DeferAcyclicVerification()),
lifecycle: lc,
logger: logger,
startTimeout: DefaultTimeout,
stopTimeout: DefaultTimeout,
}
for _, opt := range opts {
opt.apply(app)
}
for _, p := range app.provides {
app.provide(p)
}
app.provide(func() Lifecycle { return app.lifecycle })
app.provide(app.shutdowner)
app.provide(app.dotGraph)
if app.err != nil {
app.logger.Printf("Error after options were applied: %v", app.err)
return app
}
if err := app.executeInvokes(); err != nil {
app.err = err
if dig.CanVisualizeError(err) {
var b bytes.Buffer
dig.Visualize(app.container, &b, dig.VisualizeError(err))
err = errorWithGraph{
graph: b.String(),
err: err,
}
}
errorHandlerList(app.errorHooks).HandleError(err)
}
return app
} | [
"func",
"New",
"(",
"opts",
"...",
"Option",
")",
"*",
"App",
"{",
"logger",
":=",
"fxlog",
".",
"New",
"(",
")",
"\n",
"lc",
":=",
"&",
"lifecycleWrapper",
"{",
"lifecycle",
".",
"New",
"(",
"logger",
")",
"}",
"\n\n",
"app",
":=",
"&",
"App",
"... | // New creates and initializes an App, immediately executing any functions
// registered via Invoke options. See the documentation of the App struct for
// details on the application's initialization, startup, and shutdown logic. | [
"New",
"creates",
"and",
"initializes",
"an",
"App",
"immediately",
"executing",
"any",
"functions",
"registered",
"via",
"Invoke",
"options",
".",
"See",
"the",
"documentation",
"of",
"the",
"App",
"struct",
"for",
"details",
"on",
"the",
"application",
"s",
... | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L322-L364 |
151,216 | uber-go/fx | app.go | VisualizeError | func VisualizeError(err error) (string, error) {
if e, ok := err.(errWithGraph); ok && e.Graph() != "" {
return string(e.Graph()), nil
}
return "", errors.New("unable to visualize error")
} | go | func VisualizeError(err error) (string, error) {
if e, ok := err.(errWithGraph); ok && e.Graph() != "" {
return string(e.Graph()), nil
}
return "", errors.New("unable to visualize error")
} | [
"func",
"VisualizeError",
"(",
"err",
"error",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"errWithGraph",
")",
";",
"ok",
"&&",
"e",
".",
"Graph",
"(",
")",
"!=",
"\"",
"\"",
"{",
"return",
"string",
... | // VisualizeError returns the visualization of the error if available. | [
"VisualizeError",
"returns",
"the",
"visualization",
"of",
"the",
"error",
"if",
"available",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L391-L396 |
151,217 | uber-go/fx | app.go | Start | func (app *App) Start(ctx context.Context) error {
return withTimeout(ctx, app.start)
} | go | func (app *App) Start(ctx context.Context) error {
return withTimeout(ctx, app.start)
} | [
"func",
"(",
"app",
"*",
"App",
")",
"Start",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"return",
"withTimeout",
"(",
"ctx",
",",
"app",
".",
"start",
")",
"\n",
"}"
] | // Start kicks off all long-running goroutines, like network servers or
// message queue consumers. It does this by interacting with the application's
// Lifecycle.
//
// By taking a dependency on the Lifecycle type, some of the user-supplied
// functions called during initialization may have registered start and stop
// hooks. Because initialization calls constructors serially and in dependency
// order, hooks are naturally registered in dependency order too.
//
// Start executes all OnStart hooks registered with the application's
// Lifecycle, one at a time and in order. This ensures that each constructor's
// start hooks aren't executed until all its dependencies' start hooks
// complete. If any of the start hooks return an error, Start short-circuits,
// calls Stop, and returns the inciting error.
//
// Note that Start short-circuits immediately if the New constructor
// encountered any errors in application initialization. | [
"Start",
"kicks",
"off",
"all",
"long",
"-",
"running",
"goroutines",
"like",
"network",
"servers",
"or",
"message",
"queue",
"consumers",
".",
"It",
"does",
"this",
"by",
"interacting",
"with",
"the",
"application",
"s",
"Lifecycle",
".",
"By",
"taking",
"a... | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L439-L441 |
151,218 | uber-go/fx | app.go | Stop | func (app *App) Stop(ctx context.Context) error {
return withTimeout(ctx, app.lifecycle.Stop)
} | go | func (app *App) Stop(ctx context.Context) error {
return withTimeout(ctx, app.lifecycle.Stop)
} | [
"func",
"(",
"app",
"*",
"App",
")",
"Stop",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"return",
"withTimeout",
"(",
"ctx",
",",
"app",
".",
"lifecycle",
".",
"Stop",
")",
"\n",
"}"
] | // Stop gracefully stops the application. It executes any registered OnStop
// hooks in reverse order, so that each constructor's stop hooks are called
// before its dependencies' stop hooks.
//
// If the application didn't start cleanly, only hooks whose OnStart phase was
// called are executed. However, all those hooks are executed, even if some
// fail. | [
"Stop",
"gracefully",
"stops",
"the",
"application",
".",
"It",
"executes",
"any",
"registered",
"OnStop",
"hooks",
"in",
"reverse",
"order",
"so",
"that",
"each",
"constructor",
"s",
"stop",
"hooks",
"are",
"called",
"before",
"its",
"dependencies",
"stop",
"... | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L450-L452 |
151,219 | uber-go/fx | app.go | executeInvokes | func (app *App) executeInvokes() error {
// TODO: consider taking a context to limit the time spent running invocations.
var err error
for _, fn := range app.invokes {
fname := fxreflect.FuncName(fn)
app.logger.Printf("INVOKE\t\t%s", fname)
if _, ok := fn.(Option); ok {
err = fmt.Errorf("fx.Option should be passed to fx.New directly, not to fx.Invoke: fx.Invoke received %v", fn)
} else {
err = app.container.Invoke(fn)
}
if err != nil {
app.logger.Printf("Error during %q invoke: %v", fname, err)
break
}
}
return err
} | go | func (app *App) executeInvokes() error {
// TODO: consider taking a context to limit the time spent running invocations.
var err error
for _, fn := range app.invokes {
fname := fxreflect.FuncName(fn)
app.logger.Printf("INVOKE\t\t%s", fname)
if _, ok := fn.(Option); ok {
err = fmt.Errorf("fx.Option should be passed to fx.New directly, not to fx.Invoke: fx.Invoke received %v", fn)
} else {
err = app.container.Invoke(fn)
}
if err != nil {
app.logger.Printf("Error during %q invoke: %v", fname, err)
break
}
}
return err
} | [
"func",
"(",
"app",
"*",
"App",
")",
"executeInvokes",
"(",
")",
"error",
"{",
"// TODO: consider taking a context to limit the time spent running invocations.",
"var",
"err",
"error",
"\n\n",
"for",
"_",
",",
"fn",
":=",
"range",
"app",
".",
"invokes",
"{",
"fnam... | // Execute invokes in order supplied to New, returning the first error
// encountered. | [
"Execute",
"invokes",
"in",
"order",
"supplied",
"to",
"New",
"returning",
"the",
"first",
"error",
"encountered",
"."
] | 544d97a6e020226621cefffcbc38a9e2d320584c | https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/app.go#L541-L562 |
151,220 | fatih/pool | channel.go | put | func (c *channelPool) put(conn net.Conn) error {
if conn == nil {
return errors.New("connection is nil. rejecting")
}
c.mu.RLock()
defer c.mu.RUnlock()
if c.conns == nil {
// pool is closed, close passed connection
return conn.Close()
}
// put the resource back into the pool. If the pool is full, this will
// block and the default case will be executed.
select {
case c.conns <- conn:
return nil
default:
// pool is full, close passed connection
return conn.Close()
}
} | go | func (c *channelPool) put(conn net.Conn) error {
if conn == nil {
return errors.New("connection is nil. rejecting")
}
c.mu.RLock()
defer c.mu.RUnlock()
if c.conns == nil {
// pool is closed, close passed connection
return conn.Close()
}
// put the resource back into the pool. If the pool is full, this will
// block and the default case will be executed.
select {
case c.conns <- conn:
return nil
default:
// pool is full, close passed connection
return conn.Close()
}
} | [
"func",
"(",
"c",
"*",
"channelPool",
")",
"put",
"(",
"conn",
"net",
".",
"Conn",
")",
"error",
"{",
"if",
"conn",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"c",
".",
"mu",
".",
"RLock",
"(",
... | // put puts the connection back to the pool. If the pool is full or closed,
// conn is simply closed. A nil conn will be rejected. | [
"put",
"puts",
"the",
"connection",
"back",
"to",
"the",
"pool",
".",
"If",
"the",
"pool",
"is",
"full",
"or",
"closed",
"conn",
"is",
"simply",
"closed",
".",
"A",
"nil",
"conn",
"will",
"be",
"rejected",
"."
] | d817ebe42acfb2147a68af2007324c3492260c4a | https://github.com/fatih/pool/blob/d817ebe42acfb2147a68af2007324c3492260c4a/channel.go#L91-L113 |
151,221 | fatih/pool | conn.go | wrapConn | func (c *channelPool) wrapConn(conn net.Conn) net.Conn {
p := &PoolConn{c: c}
p.Conn = conn
return p
} | go | func (c *channelPool) wrapConn(conn net.Conn) net.Conn {
p := &PoolConn{c: c}
p.Conn = conn
return p
} | [
"func",
"(",
"c",
"*",
"channelPool",
")",
"wrapConn",
"(",
"conn",
"net",
".",
"Conn",
")",
"net",
".",
"Conn",
"{",
"p",
":=",
"&",
"PoolConn",
"{",
"c",
":",
"c",
"}",
"\n",
"p",
".",
"Conn",
"=",
"conn",
"\n",
"return",
"p",
"\n",
"}"
] | // newConn wraps a standard net.Conn to a poolConn net.Conn. | [
"newConn",
"wraps",
"a",
"standard",
"net",
".",
"Conn",
"to",
"a",
"poolConn",
"net",
".",
"Conn",
"."
] | d817ebe42acfb2147a68af2007324c3492260c4a | https://github.com/fatih/pool/blob/d817ebe42acfb2147a68af2007324c3492260c4a/conn.go#L39-L43 |
151,222 | imroc/req | resp.go | String | func (r *Resp) String() string {
data, _ := r.ToBytes()
return string(data)
} | go | func (r *Resp) String() string {
data, _ := r.ToBytes()
return string(data)
} | [
"func",
"(",
"r",
"*",
"Resp",
")",
"String",
"(",
")",
"string",
"{",
"data",
",",
"_",
":=",
"r",
".",
"ToBytes",
"(",
")",
"\n",
"return",
"string",
"(",
"data",
")",
"\n",
"}"
] | // String returns response body as string | [
"String",
"returns",
"response",
"body",
"as",
"string"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/resp.go#L66-L69 |
151,223 | imroc/req | resp.go | ToString | func (r *Resp) ToString() (string, error) {
data, err := r.ToBytes()
return string(data), err
} | go | func (r *Resp) ToString() (string, error) {
data, err := r.ToBytes()
return string(data), err
} | [
"func",
"(",
"r",
"*",
"Resp",
")",
"ToString",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"r",
".",
"ToBytes",
"(",
")",
"\n",
"return",
"string",
"(",
"data",
")",
",",
"err",
"\n",
"}"
] | // ToString returns response body as string,
// return error if error happend when reading
// the response body | [
"ToString",
"returns",
"response",
"body",
"as",
"string",
"return",
"error",
"if",
"error",
"happend",
"when",
"reading",
"the",
"response",
"body"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/resp.go#L74-L77 |
151,224 | imroc/req | resp.go | ToJSON | func (r *Resp) ToJSON(v interface{}) error {
data, err := r.ToBytes()
if err != nil {
return err
}
return json.Unmarshal(data, v)
} | go | func (r *Resp) ToJSON(v interface{}) error {
data, err := r.ToBytes()
if err != nil {
return err
}
return json.Unmarshal(data, v)
} | [
"func",
"(",
"r",
"*",
"Resp",
")",
"ToJSON",
"(",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"data",
",",
"err",
":=",
"r",
".",
"ToBytes",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"json",
... | // ToJSON convert json response body to struct or map | [
"ToJSON",
"convert",
"json",
"response",
"body",
"to",
"struct",
"or",
"map"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/resp.go#L80-L86 |
151,225 | imroc/req | resp.go | ToXML | func (r *Resp) ToXML(v interface{}) error {
data, err := r.ToBytes()
if err != nil {
return err
}
return xml.Unmarshal(data, v)
} | go | func (r *Resp) ToXML(v interface{}) error {
data, err := r.ToBytes()
if err != nil {
return err
}
return xml.Unmarshal(data, v)
} | [
"func",
"(",
"r",
"*",
"Resp",
")",
"ToXML",
"(",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"data",
",",
"err",
":=",
"r",
".",
"ToBytes",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"xml",
... | // ToXML convert xml response body to struct or map | [
"ToXML",
"convert",
"xml",
"response",
"body",
"to",
"struct",
"or",
"map"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/resp.go#L89-L95 |
151,226 | imroc/req | resp.go | ToFile | func (r *Resp) ToFile(name string) error {
//TODO set name to the suffix of url path if name == ""
file, err := os.Create(name)
if err != nil {
return err
}
defer file.Close()
if r.respBody != nil {
_, err = file.Write(r.respBody)
return err
}
if r.downloadProgress != nil && r.resp.ContentLength > 0 {
return r.download(file)
}
defer r.resp.Body.Close()
_, err = io.Copy(file, r.resp.Body)
return err
} | go | func (r *Resp) ToFile(name string) error {
//TODO set name to the suffix of url path if name == ""
file, err := os.Create(name)
if err != nil {
return err
}
defer file.Close()
if r.respBody != nil {
_, err = file.Write(r.respBody)
return err
}
if r.downloadProgress != nil && r.resp.ContentLength > 0 {
return r.download(file)
}
defer r.resp.Body.Close()
_, err = io.Copy(file, r.resp.Body)
return err
} | [
"func",
"(",
"r",
"*",
"Resp",
")",
"ToFile",
"(",
"name",
"string",
")",
"error",
"{",
"//TODO set name to the suffix of url path if name == \"\"",
"file",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"retu... | // ToFile download the response body to file with optional download callback | [
"ToFile",
"download",
"the",
"response",
"body",
"to",
"file",
"with",
"optional",
"download",
"callback"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/resp.go#L98-L118 |
151,227 | imroc/req | resp.go | Format | func (r *Resp) Format(s fmt.State, verb rune) {
if r == nil || r.req == nil {
return
}
if s.Flag('+') { // include header and format pretty.
fmt.Fprint(s, r.Dump())
} else if s.Flag('-') { // keep all informations in one line.
r.miniFormat(s)
} else { // auto
r.autoFormat(s)
}
} | go | func (r *Resp) Format(s fmt.State, verb rune) {
if r == nil || r.req == nil {
return
}
if s.Flag('+') { // include header and format pretty.
fmt.Fprint(s, r.Dump())
} else if s.Flag('-') { // keep all informations in one line.
r.miniFormat(s)
} else { // auto
r.autoFormat(s)
}
} | [
"func",
"(",
"r",
"*",
"Resp",
")",
"Format",
"(",
"s",
"fmt",
".",
"State",
",",
"verb",
"rune",
")",
"{",
"if",
"r",
"==",
"nil",
"||",
"r",
".",
"req",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"s",
".",
"Flag",
"(",
"'+'",
")",... | // Format fort the response | [
"Format",
"fort",
"the",
"response"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/resp.go#L204-L215 |
151,228 | imroc/req | setting.go | newClient | func newClient() *http.Client {
jar, _ := cookiejar.New(nil)
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
return &http.Client{
Jar: jar,
Transport: transport,
Timeout: 2 * time.Minute,
}
} | go | func newClient() *http.Client {
jar, _ := cookiejar.New(nil)
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
return &http.Client{
Jar: jar,
Transport: transport,
Timeout: 2 * time.Minute,
}
} | [
"func",
"newClient",
"(",
")",
"*",
"http",
".",
"Client",
"{",
"jar",
",",
"_",
":=",
"cookiejar",
".",
"New",
"(",
"nil",
")",
"\n",
"transport",
":=",
"&",
"http",
".",
"Transport",
"{",
"Proxy",
":",
"http",
".",
"ProxyFromEnvironment",
",",
"Dia... | // create a default client | [
"create",
"a",
"default",
"client"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/setting.go#L14-L33 |
151,229 | imroc/req | setting.go | Client | func (r *Req) Client() *http.Client {
if r.client == nil {
r.client = newClient()
}
return r.client
} | go | func (r *Req) Client() *http.Client {
if r.client == nil {
r.client = newClient()
}
return r.client
} | [
"func",
"(",
"r",
"*",
"Req",
")",
"Client",
"(",
")",
"*",
"http",
".",
"Client",
"{",
"if",
"r",
".",
"client",
"==",
"nil",
"{",
"r",
".",
"client",
"=",
"newClient",
"(",
")",
"\n",
"}",
"\n",
"return",
"r",
".",
"client",
"\n",
"}"
] | // Client return the default underlying http client | [
"Client",
"return",
"the",
"default",
"underlying",
"http",
"client"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/setting.go#L36-L41 |
151,230 | imroc/req | setting.go | EnableInsecureTLS | func (r *Req) EnableInsecureTLS(enable bool) {
trans := r.getTransport()
if trans == nil {
return
}
if trans.TLSClientConfig == nil {
trans.TLSClientConfig = &tls.Config{}
}
trans.TLSClientConfig.InsecureSkipVerify = enable
} | go | func (r *Req) EnableInsecureTLS(enable bool) {
trans := r.getTransport()
if trans == nil {
return
}
if trans.TLSClientConfig == nil {
trans.TLSClientConfig = &tls.Config{}
}
trans.TLSClientConfig.InsecureSkipVerify = enable
} | [
"func",
"(",
"r",
"*",
"Req",
")",
"EnableInsecureTLS",
"(",
"enable",
"bool",
")",
"{",
"trans",
":=",
"r",
".",
"getTransport",
"(",
")",
"\n",
"if",
"trans",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"trans",
".",
"TLSClientConfig",
"==",... | // EnableInsecureTLS allows insecure https | [
"EnableInsecureTLS",
"allows",
"insecure",
"https"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/setting.go#L84-L93 |
151,231 | imroc/req | setting.go | EnableCookie | func (r *Req) EnableCookie(enable bool) {
if enable {
jar, _ := cookiejar.New(nil)
r.Client().Jar = jar
} else {
r.Client().Jar = nil
}
} | go | func (r *Req) EnableCookie(enable bool) {
if enable {
jar, _ := cookiejar.New(nil)
r.Client().Jar = jar
} else {
r.Client().Jar = nil
}
} | [
"func",
"(",
"r",
"*",
"Req",
")",
"EnableCookie",
"(",
"enable",
"bool",
")",
"{",
"if",
"enable",
"{",
"jar",
",",
"_",
":=",
"cookiejar",
".",
"New",
"(",
"nil",
")",
"\n",
"r",
".",
"Client",
"(",
")",
".",
"Jar",
"=",
"jar",
"\n",
"}",
"... | // EnableCookieenable or disable cookie manager | [
"EnableCookieenable",
"or",
"disable",
"cookie",
"manager"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/setting.go#L100-L107 |
151,232 | imroc/req | setting.go | SetTimeout | func (r *Req) SetTimeout(d time.Duration) {
r.Client().Timeout = d
} | go | func (r *Req) SetTimeout(d time.Duration) {
r.Client().Timeout = d
} | [
"func",
"(",
"r",
"*",
"Req",
")",
"SetTimeout",
"(",
"d",
"time",
".",
"Duration",
")",
"{",
"r",
".",
"Client",
"(",
")",
".",
"Timeout",
"=",
"d",
"\n",
"}"
] | // SetTimeout sets the timeout for every request | [
"SetTimeout",
"sets",
"the",
"timeout",
"for",
"every",
"request"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/setting.go#L115-L117 |
151,233 | imroc/req | setting.go | SetProxyUrl | func (r *Req) SetProxyUrl(rawurl string) error {
trans := r.getTransport()
if trans == nil {
return errors.New("req: no transport")
}
u, err := url.Parse(rawurl)
if err != nil {
return err
}
trans.Proxy = http.ProxyURL(u)
return nil
} | go | func (r *Req) SetProxyUrl(rawurl string) error {
trans := r.getTransport()
if trans == nil {
return errors.New("req: no transport")
}
u, err := url.Parse(rawurl)
if err != nil {
return err
}
trans.Proxy = http.ProxyURL(u)
return nil
} | [
"func",
"(",
"r",
"*",
"Req",
")",
"SetProxyUrl",
"(",
"rawurl",
"string",
")",
"error",
"{",
"trans",
":=",
"r",
".",
"getTransport",
"(",
")",
"\n",
"if",
"trans",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}... | // SetProxyUrl set the simple proxy with fixed proxy url | [
"SetProxyUrl",
"set",
"the",
"simple",
"proxy",
"with",
"fixed",
"proxy",
"url"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/setting.go#L125-L136 |
151,234 | imroc/req | setting.go | SetXMLIndent | func (r *Req) SetXMLIndent(prefix, indent string) {
opts := r.getXMLEncOpts()
opts.prefix = prefix
opts.indent = indent
} | go | func (r *Req) SetXMLIndent(prefix, indent string) {
opts := r.getXMLEncOpts()
opts.prefix = prefix
opts.indent = indent
} | [
"func",
"(",
"r",
"*",
"Req",
")",
"SetXMLIndent",
"(",
"prefix",
",",
"indent",
"string",
")",
"{",
"opts",
":=",
"r",
".",
"getXMLEncOpts",
"(",
")",
"\n",
"opts",
".",
"prefix",
"=",
"prefix",
"\n",
"opts",
".",
"indent",
"=",
"indent",
"\n",
"}... | // SetXMLIndent sets the encoder to generate XML in which each element
// begins on a new indented line that starts with prefix and is followed by
// one or more copies of indent according to the nesting depth. | [
"SetXMLIndent",
"sets",
"the",
"encoder",
"to",
"generate",
"XML",
"in",
"which",
"each",
"element",
"begins",
"on",
"a",
"new",
"indented",
"line",
"that",
"starts",
"with",
"prefix",
"and",
"is",
"followed",
"by",
"one",
"or",
"more",
"copies",
"of",
"in... | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/setting.go#L225-L229 |
151,235 | imroc/req | dump.go | Dump | func (r *Resp) Dump() string {
dump := new(dumpBuffer)
if r.r.flag&Lcost != 0 {
dump.WriteString(fmt.Sprint(r.cost))
}
r.dumpRequest(dump)
l := dump.Len()
if l > 0 {
dump.WriteString("=================================")
l = dump.Len()
}
r.dumpResponse(dump)
return dump.String()
} | go | func (r *Resp) Dump() string {
dump := new(dumpBuffer)
if r.r.flag&Lcost != 0 {
dump.WriteString(fmt.Sprint(r.cost))
}
r.dumpRequest(dump)
l := dump.Len()
if l > 0 {
dump.WriteString("=================================")
l = dump.Len()
}
r.dumpResponse(dump)
return dump.String()
} | [
"func",
"(",
"r",
"*",
"Resp",
")",
"Dump",
"(",
")",
"string",
"{",
"dump",
":=",
"new",
"(",
"dumpBuffer",
")",
"\n",
"if",
"r",
".",
"r",
".",
"flag",
"&",
"Lcost",
"!=",
"0",
"{",
"dump",
".",
"WriteString",
"(",
"fmt",
".",
"Sprint",
"(",
... | // Dump dump the request | [
"Dump",
"dump",
"the",
"request"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/dump.go#L201-L216 |
151,236 | imroc/req | req.go | Post | func Post(url string, v ...interface{}) (*Resp, error) {
return std.Post(url, v...)
} | go | func Post(url string, v ...interface{}) (*Resp, error) {
return std.Post(url, v...)
} | [
"func",
"Post",
"(",
"url",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Resp",
",",
"error",
")",
"{",
"return",
"std",
".",
"Post",
"(",
"url",
",",
"v",
"...",
")",
"\n",
"}"
] | // Post execute a http POST request | [
"Post",
"execute",
"a",
"http",
"POST",
"request"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/req.go#L655-L657 |
151,237 | imroc/req | req.go | Put | func Put(url string, v ...interface{}) (*Resp, error) {
return std.Put(url, v...)
} | go | func Put(url string, v ...interface{}) (*Resp, error) {
return std.Put(url, v...)
} | [
"func",
"Put",
"(",
"url",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Resp",
",",
"error",
")",
"{",
"return",
"std",
".",
"Put",
"(",
"url",
",",
"v",
"...",
")",
"\n",
"}"
] | // Put execute a http PUT request | [
"Put",
"execute",
"a",
"http",
"PUT",
"request"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/req.go#L660-L662 |
151,238 | imroc/req | req.go | Head | func Head(url string, v ...interface{}) (*Resp, error) {
return std.Head(url, v...)
} | go | func Head(url string, v ...interface{}) (*Resp, error) {
return std.Head(url, v...)
} | [
"func",
"Head",
"(",
"url",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Resp",
",",
"error",
")",
"{",
"return",
"std",
".",
"Head",
"(",
"url",
",",
"v",
"...",
")",
"\n",
"}"
] | // Head execute a http HEAD request | [
"Head",
"execute",
"a",
"http",
"HEAD",
"request"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/req.go#L665-L667 |
151,239 | imroc/req | req.go | Options | func Options(url string, v ...interface{}) (*Resp, error) {
return std.Options(url, v...)
} | go | func Options(url string, v ...interface{}) (*Resp, error) {
return std.Options(url, v...)
} | [
"func",
"Options",
"(",
"url",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Resp",
",",
"error",
")",
"{",
"return",
"std",
".",
"Options",
"(",
"url",
",",
"v",
"...",
")",
"\n",
"}"
] | // Options execute a http OPTIONS request | [
"Options",
"execute",
"a",
"http",
"OPTIONS",
"request"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/req.go#L670-L672 |
151,240 | imroc/req | req.go | Delete | func Delete(url string, v ...interface{}) (*Resp, error) {
return std.Delete(url, v...)
} | go | func Delete(url string, v ...interface{}) (*Resp, error) {
return std.Delete(url, v...)
} | [
"func",
"Delete",
"(",
"url",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Resp",
",",
"error",
")",
"{",
"return",
"std",
".",
"Delete",
"(",
"url",
",",
"v",
"...",
")",
"\n",
"}"
] | // Delete execute a http DELETE request | [
"Delete",
"execute",
"a",
"http",
"DELETE",
"request"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/req.go#L675-L677 |
151,241 | imroc/req | req.go | Patch | func Patch(url string, v ...interface{}) (*Resp, error) {
return std.Patch(url, v...)
} | go | func Patch(url string, v ...interface{}) (*Resp, error) {
return std.Patch(url, v...)
} | [
"func",
"Patch",
"(",
"url",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Resp",
",",
"error",
")",
"{",
"return",
"std",
".",
"Patch",
"(",
"url",
",",
"v",
"...",
")",
"\n",
"}"
] | // Patch execute a http PATCH request | [
"Patch",
"execute",
"a",
"http",
"PATCH",
"request"
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/req.go#L680-L682 |
151,242 | imroc/req | req.go | Do | func Do(method, url string, v ...interface{}) (*Resp, error) {
return std.Do(method, url, v...)
} | go | func Do(method, url string, v ...interface{}) (*Resp, error) {
return std.Do(method, url, v...)
} | [
"func",
"Do",
"(",
"method",
",",
"url",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Resp",
",",
"error",
")",
"{",
"return",
"std",
".",
"Do",
"(",
"method",
",",
"url",
",",
"v",
"...",
")",
"\n",
"}"
] | // Do execute request. | [
"Do",
"execute",
"request",
"."
] | b355b6f6842fbda1bee879f2846cb79424cad4de | https://github.com/imroc/req/blob/b355b6f6842fbda1bee879f2846cb79424cad4de/req.go#L685-L687 |
151,243 | armon/go-metrics | circonus/circonus.go | SetGauge | func (s *CirconusSink) SetGauge(key []string, val float32) {
flatKey := s.flattenKey(key)
s.metrics.SetGauge(flatKey, int64(val))
} | go | func (s *CirconusSink) SetGauge(key []string, val float32) {
flatKey := s.flattenKey(key)
s.metrics.SetGauge(flatKey, int64(val))
} | [
"func",
"(",
"s",
"*",
"CirconusSink",
")",
"SetGauge",
"(",
"key",
"[",
"]",
"string",
",",
"val",
"float32",
")",
"{",
"flatKey",
":=",
"s",
".",
"flattenKey",
"(",
"key",
")",
"\n",
"s",
".",
"metrics",
".",
"SetGauge",
"(",
"flatKey",
",",
"int... | // SetGauge sets value for a gauge metric | [
"SetGauge",
"sets",
"value",
"for",
"a",
"gauge",
"metric"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/circonus/circonus.go#L60-L63 |
151,244 | armon/go-metrics | circonus/circonus.go | SetGaugeWithLabels | func (s *CirconusSink) SetGaugeWithLabels(key []string, val float32, labels []metrics.Label) {
flatKey := s.flattenKeyLabels(key, labels)
s.metrics.SetGauge(flatKey, int64(val))
} | go | func (s *CirconusSink) SetGaugeWithLabels(key []string, val float32, labels []metrics.Label) {
flatKey := s.flattenKeyLabels(key, labels)
s.metrics.SetGauge(flatKey, int64(val))
} | [
"func",
"(",
"s",
"*",
"CirconusSink",
")",
"SetGaugeWithLabels",
"(",
"key",
"[",
"]",
"string",
",",
"val",
"float32",
",",
"labels",
"[",
"]",
"metrics",
".",
"Label",
")",
"{",
"flatKey",
":=",
"s",
".",
"flattenKeyLabels",
"(",
"key",
",",
"labels... | // SetGaugeWithLabels sets value for a gauge metric with the given labels | [
"SetGaugeWithLabels",
"sets",
"value",
"for",
"a",
"gauge",
"metric",
"with",
"the",
"given",
"labels"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/circonus/circonus.go#L66-L69 |
151,245 | armon/go-metrics | circonus/circonus.go | IncrCounter | func (s *CirconusSink) IncrCounter(key []string, val float32) {
flatKey := s.flattenKey(key)
s.metrics.IncrementByValue(flatKey, uint64(val))
} | go | func (s *CirconusSink) IncrCounter(key []string, val float32) {
flatKey := s.flattenKey(key)
s.metrics.IncrementByValue(flatKey, uint64(val))
} | [
"func",
"(",
"s",
"*",
"CirconusSink",
")",
"IncrCounter",
"(",
"key",
"[",
"]",
"string",
",",
"val",
"float32",
")",
"{",
"flatKey",
":=",
"s",
".",
"flattenKey",
"(",
"key",
")",
"\n",
"s",
".",
"metrics",
".",
"IncrementByValue",
"(",
"flatKey",
... | // IncrCounter increments a counter metric | [
"IncrCounter",
"increments",
"a",
"counter",
"metric"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/circonus/circonus.go#L77-L80 |
151,246 | armon/go-metrics | circonus/circonus.go | IncrCounterWithLabels | func (s *CirconusSink) IncrCounterWithLabels(key []string, val float32, labels []metrics.Label) {
flatKey := s.flattenKeyLabels(key, labels)
s.metrics.IncrementByValue(flatKey, uint64(val))
} | go | func (s *CirconusSink) IncrCounterWithLabels(key []string, val float32, labels []metrics.Label) {
flatKey := s.flattenKeyLabels(key, labels)
s.metrics.IncrementByValue(flatKey, uint64(val))
} | [
"func",
"(",
"s",
"*",
"CirconusSink",
")",
"IncrCounterWithLabels",
"(",
"key",
"[",
"]",
"string",
",",
"val",
"float32",
",",
"labels",
"[",
"]",
"metrics",
".",
"Label",
")",
"{",
"flatKey",
":=",
"s",
".",
"flattenKeyLabels",
"(",
"key",
",",
"lab... | // IncrCounterWithLabels increments a counter metric with the given labels | [
"IncrCounterWithLabels",
"increments",
"a",
"counter",
"metric",
"with",
"the",
"given",
"labels"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/circonus/circonus.go#L83-L86 |
151,247 | armon/go-metrics | circonus/circonus.go | AddSample | func (s *CirconusSink) AddSample(key []string, val float32) {
flatKey := s.flattenKey(key)
s.metrics.RecordValue(flatKey, float64(val))
} | go | func (s *CirconusSink) AddSample(key []string, val float32) {
flatKey := s.flattenKey(key)
s.metrics.RecordValue(flatKey, float64(val))
} | [
"func",
"(",
"s",
"*",
"CirconusSink",
")",
"AddSample",
"(",
"key",
"[",
"]",
"string",
",",
"val",
"float32",
")",
"{",
"flatKey",
":=",
"s",
".",
"flattenKey",
"(",
"key",
")",
"\n",
"s",
".",
"metrics",
".",
"RecordValue",
"(",
"flatKey",
",",
... | // AddSample adds a sample to a histogram metric | [
"AddSample",
"adds",
"a",
"sample",
"to",
"a",
"histogram",
"metric"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/circonus/circonus.go#L89-L92 |
151,248 | armon/go-metrics | circonus/circonus.go | AddSampleWithLabels | func (s *CirconusSink) AddSampleWithLabels(key []string, val float32, labels []metrics.Label) {
flatKey := s.flattenKeyLabels(key, labels)
s.metrics.RecordValue(flatKey, float64(val))
} | go | func (s *CirconusSink) AddSampleWithLabels(key []string, val float32, labels []metrics.Label) {
flatKey := s.flattenKeyLabels(key, labels)
s.metrics.RecordValue(flatKey, float64(val))
} | [
"func",
"(",
"s",
"*",
"CirconusSink",
")",
"AddSampleWithLabels",
"(",
"key",
"[",
"]",
"string",
",",
"val",
"float32",
",",
"labels",
"[",
"]",
"metrics",
".",
"Label",
")",
"{",
"flatKey",
":=",
"s",
".",
"flattenKeyLabels",
"(",
"key",
",",
"label... | // AddSampleWithLabels adds a sample to a histogram metric with the given labels | [
"AddSampleWithLabels",
"adds",
"a",
"sample",
"to",
"a",
"histogram",
"metric",
"with",
"the",
"given",
"labels"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/circonus/circonus.go#L95-L98 |
151,249 | armon/go-metrics | statsite.go | NewStatsiteSink | func NewStatsiteSink(addr string) (*StatsiteSink, error) {
s := &StatsiteSink{
addr: addr,
metricQueue: make(chan string, 4096),
}
go s.flushMetrics()
return s, nil
} | go | func NewStatsiteSink(addr string) (*StatsiteSink, error) {
s := &StatsiteSink{
addr: addr,
metricQueue: make(chan string, 4096),
}
go s.flushMetrics()
return s, nil
} | [
"func",
"NewStatsiteSink",
"(",
"addr",
"string",
")",
"(",
"*",
"StatsiteSink",
",",
"error",
")",
"{",
"s",
":=",
"&",
"StatsiteSink",
"{",
"addr",
":",
"addr",
",",
"metricQueue",
":",
"make",
"(",
"chan",
"string",
",",
"4096",
")",
",",
"}",
"\n... | // NewStatsiteSink is used to create a new StatsiteSink | [
"NewStatsiteSink",
"is",
"used",
"to",
"create",
"a",
"new",
"StatsiteSink"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/statsite.go#L34-L41 |
151,250 | armon/go-metrics | datadog/dogstatsd.go | NewDogStatsdSink | func NewDogStatsdSink(addr string, hostName string) (*DogStatsdSink, error) {
client, err := statsd.New(addr)
if err != nil {
return nil, err
}
sink := &DogStatsdSink{
client: client,
hostName: hostName,
propagateHostname: false,
}
return sink, nil
} | go | func NewDogStatsdSink(addr string, hostName string) (*DogStatsdSink, error) {
client, err := statsd.New(addr)
if err != nil {
return nil, err
}
sink := &DogStatsdSink{
client: client,
hostName: hostName,
propagateHostname: false,
}
return sink, nil
} | [
"func",
"NewDogStatsdSink",
"(",
"addr",
"string",
",",
"hostName",
"string",
")",
"(",
"*",
"DogStatsdSink",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"statsd",
".",
"New",
"(",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"... | // NewDogStatsdSink is used to create a new DogStatsdSink with sane defaults | [
"NewDogStatsdSink",
"is",
"used",
"to",
"create",
"a",
"new",
"DogStatsdSink",
"with",
"sane",
"defaults"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/datadog/dogstatsd.go#L20-L31 |
151,251 | armon/go-metrics | datadog/dogstatsd.go | SetGauge | func (s *DogStatsdSink) SetGauge(key []string, val float32) {
s.SetGaugeWithLabels(key, val, nil)
} | go | func (s *DogStatsdSink) SetGauge(key []string, val float32) {
s.SetGaugeWithLabels(key, val, nil)
} | [
"func",
"(",
"s",
"*",
"DogStatsdSink",
")",
"SetGauge",
"(",
"key",
"[",
"]",
"string",
",",
"val",
"float32",
")",
"{",
"s",
".",
"SetGaugeWithLabels",
"(",
"key",
",",
"val",
",",
"nil",
")",
"\n",
"}"
] | // Implementation of methods in the MetricSink interface | [
"Implementation",
"of",
"methods",
"in",
"the",
"MetricSink",
"interface"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/datadog/dogstatsd.go#L86-L88 |
151,252 | armon/go-metrics | inmem_signal.go | NewInmemSignal | func NewInmemSignal(inmem *InmemSink, sig syscall.Signal, w io.Writer) *InmemSignal {
i := &InmemSignal{
signal: sig,
inm: inmem,
w: w,
sigCh: make(chan os.Signal, 1),
stopCh: make(chan struct{}),
}
signal.Notify(i.sigCh, sig)
go i.run()
return i
} | go | func NewInmemSignal(inmem *InmemSink, sig syscall.Signal, w io.Writer) *InmemSignal {
i := &InmemSignal{
signal: sig,
inm: inmem,
w: w,
sigCh: make(chan os.Signal, 1),
stopCh: make(chan struct{}),
}
signal.Notify(i.sigCh, sig)
go i.run()
return i
} | [
"func",
"NewInmemSignal",
"(",
"inmem",
"*",
"InmemSink",
",",
"sig",
"syscall",
".",
"Signal",
",",
"w",
"io",
".",
"Writer",
")",
"*",
"InmemSignal",
"{",
"i",
":=",
"&",
"InmemSignal",
"{",
"signal",
":",
"sig",
",",
"inm",
":",
"inmem",
",",
"w",... | // NewInmemSignal creates a new InmemSignal which listens for a given signal,
// and dumps the current metrics out to a writer | [
"NewInmemSignal",
"creates",
"a",
"new",
"InmemSignal",
"which",
"listens",
"for",
"a",
"given",
"signal",
"and",
"dumps",
"the",
"current",
"metrics",
"out",
"to",
"a",
"writer"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem_signal.go#L29-L40 |
151,253 | armon/go-metrics | inmem_signal.go | Stop | func (i *InmemSignal) Stop() {
i.stopLock.Lock()
defer i.stopLock.Unlock()
if i.stop {
return
}
i.stop = true
close(i.stopCh)
signal.Stop(i.sigCh)
} | go | func (i *InmemSignal) Stop() {
i.stopLock.Lock()
defer i.stopLock.Unlock()
if i.stop {
return
}
i.stop = true
close(i.stopCh)
signal.Stop(i.sigCh)
} | [
"func",
"(",
"i",
"*",
"InmemSignal",
")",
"Stop",
"(",
")",
"{",
"i",
".",
"stopLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"i",
".",
"stopLock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"i",
".",
"stop",
"{",
"return",
"\n",
"}",
"\n",
"i",
... | // Stop is used to stop the InmemSignal from listening | [
"Stop",
"is",
"used",
"to",
"stop",
"the",
"InmemSignal",
"from",
"listening"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem_signal.go#L49-L59 |
151,254 | armon/go-metrics | inmem_signal.go | dumpStats | func (i *InmemSignal) dumpStats() {
buf := bytes.NewBuffer(nil)
data := i.inm.Data()
// Skip the last period which is still being aggregated
for j := 0; j < len(data)-1; j++ {
intv := data[j]
intv.RLock()
for _, val := range intv.Gauges {
name := i.flattenLabels(val.Name, val.Labels)
fmt.Fprintf(buf, "[%v][G] '%s': %0.3f\n", intv.Interval, name, val.Value)
}
for name, vals := range intv.Points {
for _, val := range vals {
fmt.Fprintf(buf, "[%v][P] '%s': %0.3f\n", intv.Interval, name, val)
}
}
for _, agg := range intv.Counters {
name := i.flattenLabels(agg.Name, agg.Labels)
fmt.Fprintf(buf, "[%v][C] '%s': %s\n", intv.Interval, name, agg.AggregateSample)
}
for _, agg := range intv.Samples {
name := i.flattenLabels(agg.Name, agg.Labels)
fmt.Fprintf(buf, "[%v][S] '%s': %s\n", intv.Interval, name, agg.AggregateSample)
}
intv.RUnlock()
}
// Write out the bytes
i.w.Write(buf.Bytes())
} | go | func (i *InmemSignal) dumpStats() {
buf := bytes.NewBuffer(nil)
data := i.inm.Data()
// Skip the last period which is still being aggregated
for j := 0; j < len(data)-1; j++ {
intv := data[j]
intv.RLock()
for _, val := range intv.Gauges {
name := i.flattenLabels(val.Name, val.Labels)
fmt.Fprintf(buf, "[%v][G] '%s': %0.3f\n", intv.Interval, name, val.Value)
}
for name, vals := range intv.Points {
for _, val := range vals {
fmt.Fprintf(buf, "[%v][P] '%s': %0.3f\n", intv.Interval, name, val)
}
}
for _, agg := range intv.Counters {
name := i.flattenLabels(agg.Name, agg.Labels)
fmt.Fprintf(buf, "[%v][C] '%s': %s\n", intv.Interval, name, agg.AggregateSample)
}
for _, agg := range intv.Samples {
name := i.flattenLabels(agg.Name, agg.Labels)
fmt.Fprintf(buf, "[%v][S] '%s': %s\n", intv.Interval, name, agg.AggregateSample)
}
intv.RUnlock()
}
// Write out the bytes
i.w.Write(buf.Bytes())
} | [
"func",
"(",
"i",
"*",
"InmemSignal",
")",
"dumpStats",
"(",
")",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n\n",
"data",
":=",
"i",
".",
"inm",
".",
"Data",
"(",
")",
"\n",
"// Skip the last period which is still being aggregated",
"... | // dumpStats is used to dump the data to output writer | [
"dumpStats",
"is",
"used",
"to",
"dump",
"the",
"data",
"to",
"output",
"writer"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem_signal.go#L74-L104 |
151,255 | armon/go-metrics | metrics.go | UpdateFilter | func (m *Metrics) UpdateFilter(allow, block []string) {
m.UpdateFilterAndLabels(allow, block, m.AllowedLabels, m.BlockedLabels)
} | go | func (m *Metrics) UpdateFilter(allow, block []string) {
m.UpdateFilterAndLabels(allow, block, m.AllowedLabels, m.BlockedLabels)
} | [
"func",
"(",
"m",
"*",
"Metrics",
")",
"UpdateFilter",
"(",
"allow",
",",
"block",
"[",
"]",
"string",
")",
"{",
"m",
".",
"UpdateFilterAndLabels",
"(",
"allow",
",",
"block",
",",
"m",
".",
"AllowedLabels",
",",
"m",
".",
"BlockedLabels",
")",
"\n",
... | // UpdateFilter overwrites the existing filter with the given rules. | [
"UpdateFilter",
"overwrites",
"the",
"existing",
"filter",
"with",
"the",
"given",
"rules",
"."
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/metrics.go#L138-L140 |
151,256 | armon/go-metrics | metrics.go | UpdateFilterAndLabels | func (m *Metrics) UpdateFilterAndLabels(allow, block, allowedLabels, blockedLabels []string) {
m.filterLock.Lock()
defer m.filterLock.Unlock()
m.AllowedPrefixes = allow
m.BlockedPrefixes = block
if allowedLabels == nil {
// Having a white list means we take only elements from it
m.allowedLabels = nil
} else {
m.allowedLabels = make(map[string]bool)
for _, v := range allowedLabels {
m.allowedLabels[v] = true
}
}
m.blockedLabels = make(map[string]bool)
for _, v := range blockedLabels {
m.blockedLabels[v] = true
}
m.AllowedLabels = allowedLabels
m.BlockedLabels = blockedLabels
m.filter = iradix.New()
for _, prefix := range m.AllowedPrefixes {
m.filter, _, _ = m.filter.Insert([]byte(prefix), true)
}
for _, prefix := range m.BlockedPrefixes {
m.filter, _, _ = m.filter.Insert([]byte(prefix), false)
}
} | go | func (m *Metrics) UpdateFilterAndLabels(allow, block, allowedLabels, blockedLabels []string) {
m.filterLock.Lock()
defer m.filterLock.Unlock()
m.AllowedPrefixes = allow
m.BlockedPrefixes = block
if allowedLabels == nil {
// Having a white list means we take only elements from it
m.allowedLabels = nil
} else {
m.allowedLabels = make(map[string]bool)
for _, v := range allowedLabels {
m.allowedLabels[v] = true
}
}
m.blockedLabels = make(map[string]bool)
for _, v := range blockedLabels {
m.blockedLabels[v] = true
}
m.AllowedLabels = allowedLabels
m.BlockedLabels = blockedLabels
m.filter = iradix.New()
for _, prefix := range m.AllowedPrefixes {
m.filter, _, _ = m.filter.Insert([]byte(prefix), true)
}
for _, prefix := range m.BlockedPrefixes {
m.filter, _, _ = m.filter.Insert([]byte(prefix), false)
}
} | [
"func",
"(",
"m",
"*",
"Metrics",
")",
"UpdateFilterAndLabels",
"(",
"allow",
",",
"block",
",",
"allowedLabels",
",",
"blockedLabels",
"[",
"]",
"string",
")",
"{",
"m",
".",
"filterLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"filterLock",
... | // UpdateFilterAndLabels overwrites the existing filter with the given rules. | [
"UpdateFilterAndLabels",
"overwrites",
"the",
"existing",
"filter",
"with",
"the",
"given",
"rules",
"."
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/metrics.go#L143-L173 |
151,257 | armon/go-metrics | metrics.go | labelIsAllowed | func (m *Metrics) labelIsAllowed(label *Label) bool {
labelName := (*label).Name
if m.blockedLabels != nil {
_, ok := m.blockedLabels[labelName]
if ok {
// If present, let's remove this label
return false
}
}
if m.allowedLabels != nil {
_, ok := m.allowedLabels[labelName]
return ok
}
// Allow by default
return true
} | go | func (m *Metrics) labelIsAllowed(label *Label) bool {
labelName := (*label).Name
if m.blockedLabels != nil {
_, ok := m.blockedLabels[labelName]
if ok {
// If present, let's remove this label
return false
}
}
if m.allowedLabels != nil {
_, ok := m.allowedLabels[labelName]
return ok
}
// Allow by default
return true
} | [
"func",
"(",
"m",
"*",
"Metrics",
")",
"labelIsAllowed",
"(",
"label",
"*",
"Label",
")",
"bool",
"{",
"labelName",
":=",
"(",
"*",
"label",
")",
".",
"Name",
"\n",
"if",
"m",
".",
"blockedLabels",
"!=",
"nil",
"{",
"_",
",",
"ok",
":=",
"m",
"."... | // labelIsAllowed return true if a should be included in metric
// the caller should lock m.filterLock while calling this method | [
"labelIsAllowed",
"return",
"true",
"if",
"a",
"should",
"be",
"included",
"in",
"metric",
"the",
"caller",
"should",
"lock",
"m",
".",
"filterLock",
"while",
"calling",
"this",
"method"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/metrics.go#L177-L192 |
151,258 | armon/go-metrics | metrics.go | filterLabels | func (m *Metrics) filterLabels(labels []Label) []Label {
if labels == nil {
return nil
}
toReturn := []Label{}
for _, label := range labels {
if m.labelIsAllowed(&label) {
toReturn = append(toReturn, label)
}
}
return toReturn
} | go | func (m *Metrics) filterLabels(labels []Label) []Label {
if labels == nil {
return nil
}
toReturn := []Label{}
for _, label := range labels {
if m.labelIsAllowed(&label) {
toReturn = append(toReturn, label)
}
}
return toReturn
} | [
"func",
"(",
"m",
"*",
"Metrics",
")",
"filterLabels",
"(",
"labels",
"[",
"]",
"Label",
")",
"[",
"]",
"Label",
"{",
"if",
"labels",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"toReturn",
":=",
"[",
"]",
"Label",
"{",
"}",
"\n",
"for",
... | // filterLabels return only allowed labels
// the caller should lock m.filterLock while calling this method | [
"filterLabels",
"return",
"only",
"allowed",
"labels",
"the",
"caller",
"should",
"lock",
"m",
".",
"filterLock",
"while",
"calling",
"this",
"method"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/metrics.go#L196-L207 |
151,259 | armon/go-metrics | metrics.go | allowMetric | func (m *Metrics) allowMetric(key []string, labels []Label) (bool, []Label) {
m.filterLock.RLock()
defer m.filterLock.RUnlock()
if m.filter == nil || m.filter.Len() == 0 {
return m.Config.FilterDefault, m.filterLabels(labels)
}
_, allowed, ok := m.filter.Root().LongestPrefix([]byte(strings.Join(key, ".")))
if !ok {
return m.Config.FilterDefault, m.filterLabels(labels)
}
return allowed.(bool), m.filterLabels(labels)
} | go | func (m *Metrics) allowMetric(key []string, labels []Label) (bool, []Label) {
m.filterLock.RLock()
defer m.filterLock.RUnlock()
if m.filter == nil || m.filter.Len() == 0 {
return m.Config.FilterDefault, m.filterLabels(labels)
}
_, allowed, ok := m.filter.Root().LongestPrefix([]byte(strings.Join(key, ".")))
if !ok {
return m.Config.FilterDefault, m.filterLabels(labels)
}
return allowed.(bool), m.filterLabels(labels)
} | [
"func",
"(",
"m",
"*",
"Metrics",
")",
"allowMetric",
"(",
"key",
"[",
"]",
"string",
",",
"labels",
"[",
"]",
"Label",
")",
"(",
"bool",
",",
"[",
"]",
"Label",
")",
"{",
"m",
".",
"filterLock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",... | // Returns whether the metric should be allowed based on configured prefix filters
// Also return the applicable labels | [
"Returns",
"whether",
"the",
"metric",
"should",
"be",
"allowed",
"based",
"on",
"configured",
"prefix",
"filters",
"Also",
"return",
"the",
"applicable",
"labels"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/metrics.go#L211-L225 |
151,260 | armon/go-metrics | metrics.go | emitRuntimeStats | func (m *Metrics) emitRuntimeStats() {
// Export number of Goroutines
numRoutines := runtime.NumGoroutine()
m.SetGauge([]string{"runtime", "num_goroutines"}, float32(numRoutines))
// Export memory stats
var stats runtime.MemStats
runtime.ReadMemStats(&stats)
m.SetGauge([]string{"runtime", "alloc_bytes"}, float32(stats.Alloc))
m.SetGauge([]string{"runtime", "sys_bytes"}, float32(stats.Sys))
m.SetGauge([]string{"runtime", "malloc_count"}, float32(stats.Mallocs))
m.SetGauge([]string{"runtime", "free_count"}, float32(stats.Frees))
m.SetGauge([]string{"runtime", "heap_objects"}, float32(stats.HeapObjects))
m.SetGauge([]string{"runtime", "total_gc_pause_ns"}, float32(stats.PauseTotalNs))
m.SetGauge([]string{"runtime", "total_gc_runs"}, float32(stats.NumGC))
// Export info about the last few GC runs
num := stats.NumGC
// Handle wrap around
if num < m.lastNumGC {
m.lastNumGC = 0
}
// Ensure we don't scan more than 256
if num-m.lastNumGC >= 256 {
m.lastNumGC = num - 255
}
for i := m.lastNumGC; i < num; i++ {
pause := stats.PauseNs[i%256]
m.AddSample([]string{"runtime", "gc_pause_ns"}, float32(pause))
}
m.lastNumGC = num
} | go | func (m *Metrics) emitRuntimeStats() {
// Export number of Goroutines
numRoutines := runtime.NumGoroutine()
m.SetGauge([]string{"runtime", "num_goroutines"}, float32(numRoutines))
// Export memory stats
var stats runtime.MemStats
runtime.ReadMemStats(&stats)
m.SetGauge([]string{"runtime", "alloc_bytes"}, float32(stats.Alloc))
m.SetGauge([]string{"runtime", "sys_bytes"}, float32(stats.Sys))
m.SetGauge([]string{"runtime", "malloc_count"}, float32(stats.Mallocs))
m.SetGauge([]string{"runtime", "free_count"}, float32(stats.Frees))
m.SetGauge([]string{"runtime", "heap_objects"}, float32(stats.HeapObjects))
m.SetGauge([]string{"runtime", "total_gc_pause_ns"}, float32(stats.PauseTotalNs))
m.SetGauge([]string{"runtime", "total_gc_runs"}, float32(stats.NumGC))
// Export info about the last few GC runs
num := stats.NumGC
// Handle wrap around
if num < m.lastNumGC {
m.lastNumGC = 0
}
// Ensure we don't scan more than 256
if num-m.lastNumGC >= 256 {
m.lastNumGC = num - 255
}
for i := m.lastNumGC; i < num; i++ {
pause := stats.PauseNs[i%256]
m.AddSample([]string{"runtime", "gc_pause_ns"}, float32(pause))
}
m.lastNumGC = num
} | [
"func",
"(",
"m",
"*",
"Metrics",
")",
"emitRuntimeStats",
"(",
")",
"{",
"// Export number of Goroutines",
"numRoutines",
":=",
"runtime",
".",
"NumGoroutine",
"(",
")",
"\n",
"m",
".",
"SetGauge",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\... | // Emits various runtime statsitics | [
"Emits",
"various",
"runtime",
"statsitics"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/metrics.go#L236-L270 |
151,261 | armon/go-metrics | metrics.go | insert | func insert(i int, v string, s []string) []string {
s = append(s, "")
copy(s[i+1:], s[i:])
s[i] = v
return s
} | go | func insert(i int, v string, s []string) []string {
s = append(s, "")
copy(s[i+1:], s[i:])
s[i] = v
return s
} | [
"func",
"insert",
"(",
"i",
"int",
",",
"v",
"string",
",",
"s",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"s",
"=",
"append",
"(",
"s",
",",
"\"",
"\"",
")",
"\n",
"copy",
"(",
"s",
"[",
"i",
"+",
"1",
":",
"]",
",",
"s",
"[",
... | // Inserts a string value at an index into the slice | [
"Inserts",
"a",
"string",
"value",
"at",
"an",
"index",
"into",
"the",
"slice"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/metrics.go#L273-L278 |
151,262 | armon/go-metrics | start.go | DefaultConfig | func DefaultConfig(serviceName string) *Config {
c := &Config{
ServiceName: serviceName, // Use client provided service
HostName: "",
EnableHostname: true, // Enable hostname prefix
EnableRuntimeMetrics: true, // Enable runtime profiling
EnableTypePrefix: false, // Disable type prefix
TimerGranularity: time.Millisecond, // Timers are in milliseconds
ProfileInterval: time.Second, // Poll runtime every second
FilterDefault: true, // Don't filter metrics by default
}
// Try to get the hostname
name, _ := os.Hostname()
c.HostName = name
return c
} | go | func DefaultConfig(serviceName string) *Config {
c := &Config{
ServiceName: serviceName, // Use client provided service
HostName: "",
EnableHostname: true, // Enable hostname prefix
EnableRuntimeMetrics: true, // Enable runtime profiling
EnableTypePrefix: false, // Disable type prefix
TimerGranularity: time.Millisecond, // Timers are in milliseconds
ProfileInterval: time.Second, // Poll runtime every second
FilterDefault: true, // Don't filter metrics by default
}
// Try to get the hostname
name, _ := os.Hostname()
c.HostName = name
return c
} | [
"func",
"DefaultConfig",
"(",
"serviceName",
"string",
")",
"*",
"Config",
"{",
"c",
":=",
"&",
"Config",
"{",
"ServiceName",
":",
"serviceName",
",",
"// Use client provided service",
"HostName",
":",
"\"",
"\"",
",",
"EnableHostname",
":",
"true",
",",
"// E... | // DefaultConfig provides a sane default configuration | [
"DefaultConfig",
"provides",
"a",
"sane",
"default",
"configuration"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/start.go#L52-L68 |
151,263 | armon/go-metrics | start.go | New | func New(conf *Config, sink MetricSink) (*Metrics, error) {
met := &Metrics{}
met.Config = *conf
met.sink = sink
met.UpdateFilterAndLabels(conf.AllowedPrefixes, conf.BlockedPrefixes, conf.AllowedLabels, conf.BlockedLabels)
// Start the runtime collector
if conf.EnableRuntimeMetrics {
go met.collectStats()
}
return met, nil
} | go | func New(conf *Config, sink MetricSink) (*Metrics, error) {
met := &Metrics{}
met.Config = *conf
met.sink = sink
met.UpdateFilterAndLabels(conf.AllowedPrefixes, conf.BlockedPrefixes, conf.AllowedLabels, conf.BlockedLabels)
// Start the runtime collector
if conf.EnableRuntimeMetrics {
go met.collectStats()
}
return met, nil
} | [
"func",
"New",
"(",
"conf",
"*",
"Config",
",",
"sink",
"MetricSink",
")",
"(",
"*",
"Metrics",
",",
"error",
")",
"{",
"met",
":=",
"&",
"Metrics",
"{",
"}",
"\n",
"met",
".",
"Config",
"=",
"*",
"conf",
"\n",
"met",
".",
"sink",
"=",
"sink",
... | // New is used to create a new instance of Metrics | [
"New",
"is",
"used",
"to",
"create",
"a",
"new",
"instance",
"of",
"Metrics"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/start.go#L71-L82 |
151,264 | armon/go-metrics | start.go | NewGlobal | func NewGlobal(conf *Config, sink MetricSink) (*Metrics, error) {
metrics, err := New(conf, sink)
if err == nil {
globalMetrics.Store(metrics)
}
return metrics, err
} | go | func NewGlobal(conf *Config, sink MetricSink) (*Metrics, error) {
metrics, err := New(conf, sink)
if err == nil {
globalMetrics.Store(metrics)
}
return metrics, err
} | [
"func",
"NewGlobal",
"(",
"conf",
"*",
"Config",
",",
"sink",
"MetricSink",
")",
"(",
"*",
"Metrics",
",",
"error",
")",
"{",
"metrics",
",",
"err",
":=",
"New",
"(",
"conf",
",",
"sink",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"globalMetrics",
"... | // NewGlobal is the same as New, but it assigns the metrics object to be
// used globally as well as returning it. | [
"NewGlobal",
"is",
"the",
"same",
"as",
"New",
"but",
"it",
"assigns",
"the",
"metrics",
"object",
"to",
"be",
"used",
"globally",
"as",
"well",
"as",
"returning",
"it",
"."
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/start.go#L86-L92 |
151,265 | armon/go-metrics | start.go | SetGauge | func SetGauge(key []string, val float32) {
globalMetrics.Load().(*Metrics).SetGauge(key, val)
} | go | func SetGauge(key []string, val float32) {
globalMetrics.Load().(*Metrics).SetGauge(key, val)
} | [
"func",
"SetGauge",
"(",
"key",
"[",
"]",
"string",
",",
"val",
"float32",
")",
"{",
"globalMetrics",
".",
"Load",
"(",
")",
".",
"(",
"*",
"Metrics",
")",
".",
"SetGauge",
"(",
"key",
",",
"val",
")",
"\n",
"}"
] | // Proxy all the methods to the globalMetrics instance | [
"Proxy",
"all",
"the",
"methods",
"to",
"the",
"globalMetrics",
"instance"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/start.go#L95-L97 |
151,266 | armon/go-metrics | statsd.go | NewStatsdSink | func NewStatsdSink(addr string) (*StatsdSink, error) {
s := &StatsdSink{
addr: addr,
metricQueue: make(chan string, 4096),
}
go s.flushMetrics()
return s, nil
} | go | func NewStatsdSink(addr string) (*StatsdSink, error) {
s := &StatsdSink{
addr: addr,
metricQueue: make(chan string, 4096),
}
go s.flushMetrics()
return s, nil
} | [
"func",
"NewStatsdSink",
"(",
"addr",
"string",
")",
"(",
"*",
"StatsdSink",
",",
"error",
")",
"{",
"s",
":=",
"&",
"StatsdSink",
"{",
"addr",
":",
"addr",
",",
"metricQueue",
":",
"make",
"(",
"chan",
"string",
",",
"4096",
")",
",",
"}",
"\n",
"... | // NewStatsdSink is used to create a new StatsdSink | [
"NewStatsdSink",
"is",
"used",
"to",
"create",
"a",
"new",
"StatsdSink"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/statsd.go#L34-L41 |
151,267 | armon/go-metrics | prometheus/prometheus.go | NewPrometheusSinkFrom | func NewPrometheusSinkFrom(opts PrometheusOpts) (*PrometheusSink, error) {
sink := &PrometheusSink{
gauges: make(map[string]prometheus.Gauge),
summaries: make(map[string]prometheus.Summary),
counters: make(map[string]prometheus.Counter),
updates: make(map[string]time.Time),
expiration: opts.Expiration,
}
return sink, prometheus.Register(sink)
} | go | func NewPrometheusSinkFrom(opts PrometheusOpts) (*PrometheusSink, error) {
sink := &PrometheusSink{
gauges: make(map[string]prometheus.Gauge),
summaries: make(map[string]prometheus.Summary),
counters: make(map[string]prometheus.Counter),
updates: make(map[string]time.Time),
expiration: opts.Expiration,
}
return sink, prometheus.Register(sink)
} | [
"func",
"NewPrometheusSinkFrom",
"(",
"opts",
"PrometheusOpts",
")",
"(",
"*",
"PrometheusSink",
",",
"error",
")",
"{",
"sink",
":=",
"&",
"PrometheusSink",
"{",
"gauges",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"prometheus",
".",
"Gauge",
")",
",",
... | // NewPrometheusSinkFrom creates a new PrometheusSink using the passed options. | [
"NewPrometheusSinkFrom",
"creates",
"a",
"new",
"PrometheusSink",
"using",
"the",
"passed",
"options",
"."
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/prometheus/prometheus.go#L47-L57 |
151,268 | armon/go-metrics | prometheus/prometheus.go | Describe | func (p *PrometheusSink) Describe(c chan<- *prometheus.Desc) {
// We must emit some description otherwise an error is returned. This
// description isn't shown to the user!
prometheus.NewGauge(prometheus.GaugeOpts{Name: "Dummy", Help: "Dummy"}).Describe(c)
} | go | func (p *PrometheusSink) Describe(c chan<- *prometheus.Desc) {
// We must emit some description otherwise an error is returned. This
// description isn't shown to the user!
prometheus.NewGauge(prometheus.GaugeOpts{Name: "Dummy", Help: "Dummy"}).Describe(c)
} | [
"func",
"(",
"p",
"*",
"PrometheusSink",
")",
"Describe",
"(",
"c",
"chan",
"<-",
"*",
"prometheus",
".",
"Desc",
")",
"{",
"// We must emit some description otherwise an error is returned. This",
"// description isn't shown to the user!",
"prometheus",
".",
"NewGauge",
"... | // Describe is needed to meet the Collector interface. | [
"Describe",
"is",
"needed",
"to",
"meet",
"the",
"Collector",
"interface",
"."
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/prometheus/prometheus.go#L60-L64 |
151,269 | armon/go-metrics | prometheus/prometheus.go | Collect | func (p *PrometheusSink) Collect(c chan<- prometheus.Metric) {
p.mu.Lock()
defer p.mu.Unlock()
expire := p.expiration != 0
now := time.Now()
for k, v := range p.gauges {
last := p.updates[k]
if expire && last.Add(p.expiration).Before(now) {
delete(p.updates, k)
delete(p.gauges, k)
} else {
v.Collect(c)
}
}
for k, v := range p.summaries {
last := p.updates[k]
if expire && last.Add(p.expiration).Before(now) {
delete(p.updates, k)
delete(p.summaries, k)
} else {
v.Collect(c)
}
}
for k, v := range p.counters {
last := p.updates[k]
if expire && last.Add(p.expiration).Before(now) {
delete(p.updates, k)
delete(p.counters, k)
} else {
v.Collect(c)
}
}
} | go | func (p *PrometheusSink) Collect(c chan<- prometheus.Metric) {
p.mu.Lock()
defer p.mu.Unlock()
expire := p.expiration != 0
now := time.Now()
for k, v := range p.gauges {
last := p.updates[k]
if expire && last.Add(p.expiration).Before(now) {
delete(p.updates, k)
delete(p.gauges, k)
} else {
v.Collect(c)
}
}
for k, v := range p.summaries {
last := p.updates[k]
if expire && last.Add(p.expiration).Before(now) {
delete(p.updates, k)
delete(p.summaries, k)
} else {
v.Collect(c)
}
}
for k, v := range p.counters {
last := p.updates[k]
if expire && last.Add(p.expiration).Before(now) {
delete(p.updates, k)
delete(p.counters, k)
} else {
v.Collect(c)
}
}
} | [
"func",
"(",
"p",
"*",
"PrometheusSink",
")",
"Collect",
"(",
"c",
"chan",
"<-",
"prometheus",
".",
"Metric",
")",
"{",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"expire",
":=",
"p",
... | // Collect meets the collection interface and allows us to enforce our expiration
// logic to clean up ephemeral metrics if their value haven't been set for a
// duration exceeding our allowed expiration time. | [
"Collect",
"meets",
"the",
"collection",
"interface",
"and",
"allows",
"us",
"to",
"enforce",
"our",
"expiration",
"logic",
"to",
"clean",
"up",
"ephemeral",
"metrics",
"if",
"their",
"value",
"haven",
"t",
"been",
"set",
"for",
"a",
"duration",
"exceeding",
... | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/prometheus/prometheus.go#L69-L102 |
151,270 | armon/go-metrics | inmem.go | NewIntervalMetrics | func NewIntervalMetrics(intv time.Time) *IntervalMetrics {
return &IntervalMetrics{
Interval: intv,
Gauges: make(map[string]GaugeValue),
Points: make(map[string][]float32),
Counters: make(map[string]SampledValue),
Samples: make(map[string]SampledValue),
}
} | go | func NewIntervalMetrics(intv time.Time) *IntervalMetrics {
return &IntervalMetrics{
Interval: intv,
Gauges: make(map[string]GaugeValue),
Points: make(map[string][]float32),
Counters: make(map[string]SampledValue),
Samples: make(map[string]SampledValue),
}
} | [
"func",
"NewIntervalMetrics",
"(",
"intv",
"time",
".",
"Time",
")",
"*",
"IntervalMetrics",
"{",
"return",
"&",
"IntervalMetrics",
"{",
"Interval",
":",
"intv",
",",
"Gauges",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"GaugeValue",
")",
",",
"Points",
... | // NewIntervalMetrics creates a new IntervalMetrics for a given interval | [
"NewIntervalMetrics",
"creates",
"a",
"new",
"IntervalMetrics",
"for",
"a",
"given",
"interval"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem.go#L59-L67 |
151,271 | armon/go-metrics | inmem.go | Stddev | func (a *AggregateSample) Stddev() float64 {
num := (float64(a.Count) * a.SumSq) - math.Pow(a.Sum, 2)
div := float64(a.Count * (a.Count - 1))
if div == 0 {
return 0
}
return math.Sqrt(num / div)
} | go | func (a *AggregateSample) Stddev() float64 {
num := (float64(a.Count) * a.SumSq) - math.Pow(a.Sum, 2)
div := float64(a.Count * (a.Count - 1))
if div == 0 {
return 0
}
return math.Sqrt(num / div)
} | [
"func",
"(",
"a",
"*",
"AggregateSample",
")",
"Stddev",
"(",
")",
"float64",
"{",
"num",
":=",
"(",
"float64",
"(",
"a",
".",
"Count",
")",
"*",
"a",
".",
"SumSq",
")",
"-",
"math",
".",
"Pow",
"(",
"a",
".",
"Sum",
",",
"2",
")",
"\n",
"div... | // Computes a Stddev of the values | [
"Computes",
"a",
"Stddev",
"of",
"the",
"values"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem.go#L82-L89 |
151,272 | armon/go-metrics | inmem.go | Mean | func (a *AggregateSample) Mean() float64 {
if a.Count == 0 {
return 0
}
return a.Sum / float64(a.Count)
} | go | func (a *AggregateSample) Mean() float64 {
if a.Count == 0 {
return 0
}
return a.Sum / float64(a.Count)
} | [
"func",
"(",
"a",
"*",
"AggregateSample",
")",
"Mean",
"(",
")",
"float64",
"{",
"if",
"a",
".",
"Count",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"a",
".",
"Sum",
"/",
"float64",
"(",
"a",
".",
"Count",
")",
"\n",
"}"
] | // Computes a mean of the values | [
"Computes",
"a",
"mean",
"of",
"the",
"values"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem.go#L92-L97 |
151,273 | armon/go-metrics | inmem.go | Ingest | func (a *AggregateSample) Ingest(v float64, rateDenom float64) {
a.Count++
a.Sum += v
a.SumSq += (v * v)
if v < a.Min || a.Count == 1 {
a.Min = v
}
if v > a.Max || a.Count == 1 {
a.Max = v
}
a.Rate = float64(a.Sum) / rateDenom
a.LastUpdated = time.Now()
} | go | func (a *AggregateSample) Ingest(v float64, rateDenom float64) {
a.Count++
a.Sum += v
a.SumSq += (v * v)
if v < a.Min || a.Count == 1 {
a.Min = v
}
if v > a.Max || a.Count == 1 {
a.Max = v
}
a.Rate = float64(a.Sum) / rateDenom
a.LastUpdated = time.Now()
} | [
"func",
"(",
"a",
"*",
"AggregateSample",
")",
"Ingest",
"(",
"v",
"float64",
",",
"rateDenom",
"float64",
")",
"{",
"a",
".",
"Count",
"++",
"\n",
"a",
".",
"Sum",
"+=",
"v",
"\n",
"a",
".",
"SumSq",
"+=",
"(",
"v",
"*",
"v",
")",
"\n",
"if",
... | // Ingest is used to update a sample | [
"Ingest",
"is",
"used",
"to",
"update",
"a",
"sample"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem.go#L100-L112 |
151,274 | armon/go-metrics | inmem.go | NewInmemSink | func NewInmemSink(interval, retain time.Duration) *InmemSink {
rateTimeUnit := time.Second
i := &InmemSink{
interval: interval,
retain: retain,
maxIntervals: int(retain / interval),
rateDenom: float64(interval.Nanoseconds()) / float64(rateTimeUnit.Nanoseconds()),
}
i.intervals = make([]*IntervalMetrics, 0, i.maxIntervals)
return i
} | go | func NewInmemSink(interval, retain time.Duration) *InmemSink {
rateTimeUnit := time.Second
i := &InmemSink{
interval: interval,
retain: retain,
maxIntervals: int(retain / interval),
rateDenom: float64(interval.Nanoseconds()) / float64(rateTimeUnit.Nanoseconds()),
}
i.intervals = make([]*IntervalMetrics, 0, i.maxIntervals)
return i
} | [
"func",
"NewInmemSink",
"(",
"interval",
",",
"retain",
"time",
".",
"Duration",
")",
"*",
"InmemSink",
"{",
"rateTimeUnit",
":=",
"time",
".",
"Second",
"\n",
"i",
":=",
"&",
"InmemSink",
"{",
"interval",
":",
"interval",
",",
"retain",
":",
"retain",
"... | // NewInmemSink is used to construct a new in-memory sink.
// Uses an aggregation interval and maximum retention period. | [
"NewInmemSink",
"is",
"used",
"to",
"construct",
"a",
"new",
"in",
"-",
"memory",
"sink",
".",
"Uses",
"an",
"aggregation",
"interval",
"and",
"maximum",
"retention",
"period",
"."
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem.go#L145-L155 |
151,275 | armon/go-metrics | inmem.go | Data | func (i *InmemSink) Data() []*IntervalMetrics {
// Get the current interval, forces creation
i.getInterval()
i.intervalLock.RLock()
defer i.intervalLock.RUnlock()
n := len(i.intervals)
intervals := make([]*IntervalMetrics, n)
copy(intervals[:n-1], i.intervals[:n-1])
current := i.intervals[n-1]
// make its own copy for current interval
intervals[n-1] = &IntervalMetrics{}
copyCurrent := intervals[n-1]
current.RLock()
*copyCurrent = *current
copyCurrent.Gauges = make(map[string]GaugeValue, len(current.Gauges))
for k, v := range current.Gauges {
copyCurrent.Gauges[k] = v
}
// saved values will be not change, just copy its link
copyCurrent.Points = make(map[string][]float32, len(current.Points))
for k, v := range current.Points {
copyCurrent.Points[k] = v
}
copyCurrent.Counters = make(map[string]SampledValue, len(current.Counters))
for k, v := range current.Counters {
copyCurrent.Counters[k] = v.deepCopy()
}
copyCurrent.Samples = make(map[string]SampledValue, len(current.Samples))
for k, v := range current.Samples {
copyCurrent.Samples[k] = v.deepCopy()
}
current.RUnlock()
return intervals
} | go | func (i *InmemSink) Data() []*IntervalMetrics {
// Get the current interval, forces creation
i.getInterval()
i.intervalLock.RLock()
defer i.intervalLock.RUnlock()
n := len(i.intervals)
intervals := make([]*IntervalMetrics, n)
copy(intervals[:n-1], i.intervals[:n-1])
current := i.intervals[n-1]
// make its own copy for current interval
intervals[n-1] = &IntervalMetrics{}
copyCurrent := intervals[n-1]
current.RLock()
*copyCurrent = *current
copyCurrent.Gauges = make(map[string]GaugeValue, len(current.Gauges))
for k, v := range current.Gauges {
copyCurrent.Gauges[k] = v
}
// saved values will be not change, just copy its link
copyCurrent.Points = make(map[string][]float32, len(current.Points))
for k, v := range current.Points {
copyCurrent.Points[k] = v
}
copyCurrent.Counters = make(map[string]SampledValue, len(current.Counters))
for k, v := range current.Counters {
copyCurrent.Counters[k] = v.deepCopy()
}
copyCurrent.Samples = make(map[string]SampledValue, len(current.Samples))
for k, v := range current.Samples {
copyCurrent.Samples[k] = v.deepCopy()
}
current.RUnlock()
return intervals
} | [
"func",
"(",
"i",
"*",
"InmemSink",
")",
"Data",
"(",
")",
"[",
"]",
"*",
"IntervalMetrics",
"{",
"// Get the current interval, forces creation",
"i",
".",
"getInterval",
"(",
")",
"\n\n",
"i",
".",
"intervalLock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"i... | // Data is used to retrieve all the aggregated metrics
// Intervals may be in use, and a read lock should be acquired | [
"Data",
"is",
"used",
"to",
"retrieve",
"all",
"the",
"aggregated",
"metrics",
"Intervals",
"may",
"be",
"in",
"use",
"and",
"a",
"read",
"lock",
"should",
"be",
"acquired"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem.go#L228-L267 |
151,276 | armon/go-metrics | inmem.go | getInterval | func (i *InmemSink) getInterval() *IntervalMetrics {
intv := time.Now().Truncate(i.interval)
if m := i.getExistingInterval(intv); m != nil {
return m
}
return i.createInterval(intv)
} | go | func (i *InmemSink) getInterval() *IntervalMetrics {
intv := time.Now().Truncate(i.interval)
if m := i.getExistingInterval(intv); m != nil {
return m
}
return i.createInterval(intv)
} | [
"func",
"(",
"i",
"*",
"InmemSink",
")",
"getInterval",
"(",
")",
"*",
"IntervalMetrics",
"{",
"intv",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Truncate",
"(",
"i",
".",
"interval",
")",
"\n",
"if",
"m",
":=",
"i",
".",
"getExistingInterval",
"(",
... | // getInterval returns the current interval to write to | [
"getInterval",
"returns",
"the",
"current",
"interval",
"to",
"write",
"to"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem.go#L304-L310 |
151,277 | armon/go-metrics | inmem_endpoint.go | deepCopy | func (source *SampledValue) deepCopy() SampledValue {
dest := *source
if source.AggregateSample != nil {
dest.AggregateSample = &AggregateSample{}
*dest.AggregateSample = *source.AggregateSample
}
return dest
} | go | func (source *SampledValue) deepCopy() SampledValue {
dest := *source
if source.AggregateSample != nil {
dest.AggregateSample = &AggregateSample{}
*dest.AggregateSample = *source.AggregateSample
}
return dest
} | [
"func",
"(",
"source",
"*",
"SampledValue",
")",
"deepCopy",
"(",
")",
"SampledValue",
"{",
"dest",
":=",
"*",
"source",
"\n",
"if",
"source",
".",
"AggregateSample",
"!=",
"nil",
"{",
"dest",
".",
"AggregateSample",
"=",
"&",
"AggregateSample",
"{",
"}",
... | // deepCopy allocates a new instance of AggregateSample | [
"deepCopy",
"allocates",
"a",
"new",
"instance",
"of",
"AggregateSample"
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem_endpoint.go#L45-L52 |
151,278 | armon/go-metrics | inmem_endpoint.go | DisplayMetrics | func (i *InmemSink) DisplayMetrics(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
data := i.Data()
var interval *IntervalMetrics
n := len(data)
switch {
case n == 0:
return nil, fmt.Errorf("no metric intervals have been initialized yet")
case n == 1:
// Show the current interval if it's all we have
interval = data[0]
default:
// Show the most recent finished interval if we have one
interval = data[n-2]
}
interval.RLock()
defer interval.RUnlock()
summary := MetricsSummary{
Timestamp: interval.Interval.Round(time.Second).UTC().String(),
Gauges: make([]GaugeValue, 0, len(interval.Gauges)),
Points: make([]PointValue, 0, len(interval.Points)),
}
// Format and sort the output of each metric type, so it gets displayed in a
// deterministic order.
for name, points := range interval.Points {
summary.Points = append(summary.Points, PointValue{name, points})
}
sort.Slice(summary.Points, func(i, j int) bool {
return summary.Points[i].Name < summary.Points[j].Name
})
for hash, value := range interval.Gauges {
value.Hash = hash
value.DisplayLabels = make(map[string]string)
for _, label := range value.Labels {
value.DisplayLabels[label.Name] = label.Value
}
value.Labels = nil
summary.Gauges = append(summary.Gauges, value)
}
sort.Slice(summary.Gauges, func(i, j int) bool {
return summary.Gauges[i].Hash < summary.Gauges[j].Hash
})
summary.Counters = formatSamples(interval.Counters)
summary.Samples = formatSamples(interval.Samples)
return summary, nil
} | go | func (i *InmemSink) DisplayMetrics(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
data := i.Data()
var interval *IntervalMetrics
n := len(data)
switch {
case n == 0:
return nil, fmt.Errorf("no metric intervals have been initialized yet")
case n == 1:
// Show the current interval if it's all we have
interval = data[0]
default:
// Show the most recent finished interval if we have one
interval = data[n-2]
}
interval.RLock()
defer interval.RUnlock()
summary := MetricsSummary{
Timestamp: interval.Interval.Round(time.Second).UTC().String(),
Gauges: make([]GaugeValue, 0, len(interval.Gauges)),
Points: make([]PointValue, 0, len(interval.Points)),
}
// Format and sort the output of each metric type, so it gets displayed in a
// deterministic order.
for name, points := range interval.Points {
summary.Points = append(summary.Points, PointValue{name, points})
}
sort.Slice(summary.Points, func(i, j int) bool {
return summary.Points[i].Name < summary.Points[j].Name
})
for hash, value := range interval.Gauges {
value.Hash = hash
value.DisplayLabels = make(map[string]string)
for _, label := range value.Labels {
value.DisplayLabels[label.Name] = label.Value
}
value.Labels = nil
summary.Gauges = append(summary.Gauges, value)
}
sort.Slice(summary.Gauges, func(i, j int) bool {
return summary.Gauges[i].Hash < summary.Gauges[j].Hash
})
summary.Counters = formatSamples(interval.Counters)
summary.Samples = formatSamples(interval.Samples)
return summary, nil
} | [
"func",
"(",
"i",
"*",
"InmemSink",
")",
"DisplayMetrics",
"(",
"resp",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"data",
":=",
"i",
".",
"Data",
"(",
")",
"\n\n... | // DisplayMetrics returns a summary of the metrics from the most recent finished interval. | [
"DisplayMetrics",
"returns",
"a",
"summary",
"of",
"the",
"metrics",
"from",
"the",
"most",
"recent",
"finished",
"interval",
"."
] | ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5 | https://github.com/armon/go-metrics/blob/ec5e00d3c878b2a97bbe0884ef45ffd1b4f669f5/inmem_endpoint.go#L55-L107 |
151,279 | levigross/grequests | session.go | NewSession | func NewSession(ro *RequestOptions) *Session {
if ro == nil {
ro = &RequestOptions{}
}
ro.UseCookieJar = true
return &Session{RequestOptions: ro, HTTPClient: BuildHTTPClient(*ro)}
} | go | func NewSession(ro *RequestOptions) *Session {
if ro == nil {
ro = &RequestOptions{}
}
ro.UseCookieJar = true
return &Session{RequestOptions: ro, HTTPClient: BuildHTTPClient(*ro)}
} | [
"func",
"NewSession",
"(",
"ro",
"*",
"RequestOptions",
")",
"*",
"Session",
"{",
"if",
"ro",
"==",
"nil",
"{",
"ro",
"=",
"&",
"RequestOptions",
"{",
"}",
"\n",
"}",
"\n\n",
"ro",
".",
"UseCookieJar",
"=",
"true",
"\n\n",
"return",
"&",
"Session",
"... | // NewSession returns a session struct which enables can be used to maintain establish a persistent state with the
// server
// This function will set UseCookieJar to true as that is the purpose of using the session | [
"NewSession",
"returns",
"a",
"session",
"struct",
"which",
"enables",
"can",
"be",
"used",
"to",
"maintain",
"establish",
"a",
"persistent",
"state",
"with",
"the",
"server",
"This",
"function",
"will",
"set",
"UseCookieJar",
"to",
"true",
"as",
"that",
"is",... | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/session.go#L18-L26 |
151,280 | levigross/grequests | session.go | combineRequestOptions | func (s *Session) combineRequestOptions(ro *RequestOptions) *RequestOptions {
if ro == nil {
ro = &RequestOptions{}
}
if ro.UserAgent == "" && s.RequestOptions.UserAgent != "" {
ro.UserAgent = s.RequestOptions.UserAgent
}
if ro.Host == "" && s.RequestOptions.Host != "" {
ro.Host = s.RequestOptions.Host
}
if ro.Auth == nil && s.RequestOptions.Auth != nil {
ro.Auth = s.RequestOptions.Auth
}
if len(s.RequestOptions.Headers) > 0 || len(ro.Headers) > 0 {
headers := make(map[string]string)
for k, v := range s.RequestOptions.Headers {
headers[k] = v
}
for k, v := range ro.Headers {
headers[k] = v
}
ro.Headers = headers
}
return ro
} | go | func (s *Session) combineRequestOptions(ro *RequestOptions) *RequestOptions {
if ro == nil {
ro = &RequestOptions{}
}
if ro.UserAgent == "" && s.RequestOptions.UserAgent != "" {
ro.UserAgent = s.RequestOptions.UserAgent
}
if ro.Host == "" && s.RequestOptions.Host != "" {
ro.Host = s.RequestOptions.Host
}
if ro.Auth == nil && s.RequestOptions.Auth != nil {
ro.Auth = s.RequestOptions.Auth
}
if len(s.RequestOptions.Headers) > 0 || len(ro.Headers) > 0 {
headers := make(map[string]string)
for k, v := range s.RequestOptions.Headers {
headers[k] = v
}
for k, v := range ro.Headers {
headers[k] = v
}
ro.Headers = headers
}
return ro
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"combineRequestOptions",
"(",
"ro",
"*",
"RequestOptions",
")",
"*",
"RequestOptions",
"{",
"if",
"ro",
"==",
"nil",
"{",
"ro",
"=",
"&",
"RequestOptions",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"ro",
".",
"UserAgent"... | // Combine session options and request options
// 1. UserAgent
// 2. Host
// 3. Auth
// 4. Headers | [
"Combine",
"session",
"options",
"and",
"request",
"options",
"1",
".",
"UserAgent",
"2",
".",
"Host",
"3",
".",
"Auth",
"4",
".",
"Headers"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/session.go#L33-L61 |
151,281 | levigross/grequests | request.go | DoRegularRequest | func DoRegularRequest(requestVerb, url string, ro *RequestOptions) (*Response, error) {
return buildResponse(buildRequest(requestVerb, url, ro, nil))
} | go | func DoRegularRequest(requestVerb, url string, ro *RequestOptions) (*Response, error) {
return buildResponse(buildRequest(requestVerb, url, ro, nil))
} | [
"func",
"DoRegularRequest",
"(",
"requestVerb",
",",
"url",
"string",
",",
"ro",
"*",
"RequestOptions",
")",
"(",
"*",
"Response",
",",
"error",
")",
"{",
"return",
"buildResponse",
"(",
"buildRequest",
"(",
"requestVerb",
",",
"url",
",",
"ro",
",",
"nil"... | // DoRegularRequest adds generic test functionality | [
"DoRegularRequest",
"adds",
"generic",
"test",
"functionality"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/request.go#L144-L146 |
151,282 | levigross/grequests | request.go | buildRequest | func buildRequest(httpMethod, url string, ro *RequestOptions, httpClient *http.Client) (*http.Response, error) {
if ro == nil {
ro = &RequestOptions{}
}
if ro.CookieJar != nil {
ro.UseCookieJar = true
}
// Create our own HTTP client
if httpClient == nil {
httpClient = BuildHTTPClient(*ro)
}
var err error // we don't want to shadow url so we won't use :=
switch {
case len(ro.Params) != 0:
if url, err = buildURLParams(url, ro.Params); err != nil {
return nil, err
}
case ro.QueryStruct != nil:
if url, err = buildURLStruct(url, ro.QueryStruct); err != nil {
return nil, err
}
}
// Build the request
req, err := buildHTTPRequest(httpMethod, url, ro)
if err != nil {
return nil, err
}
// Do we need to add any HTTP headers or Basic Auth?
addHTTPHeaders(ro, req)
addCookies(ro, req)
addRedirectFunctionality(httpClient, ro)
if ro.Context != nil {
req = req.WithContext(ro.Context)
}
if ro.BeforeRequest != nil {
if err := ro.BeforeRequest(req); err != nil {
return nil, err
}
}
return httpClient.Do(req)
} | go | func buildRequest(httpMethod, url string, ro *RequestOptions, httpClient *http.Client) (*http.Response, error) {
if ro == nil {
ro = &RequestOptions{}
}
if ro.CookieJar != nil {
ro.UseCookieJar = true
}
// Create our own HTTP client
if httpClient == nil {
httpClient = BuildHTTPClient(*ro)
}
var err error // we don't want to shadow url so we won't use :=
switch {
case len(ro.Params) != 0:
if url, err = buildURLParams(url, ro.Params); err != nil {
return nil, err
}
case ro.QueryStruct != nil:
if url, err = buildURLStruct(url, ro.QueryStruct); err != nil {
return nil, err
}
}
// Build the request
req, err := buildHTTPRequest(httpMethod, url, ro)
if err != nil {
return nil, err
}
// Do we need to add any HTTP headers or Basic Auth?
addHTTPHeaders(ro, req)
addCookies(ro, req)
addRedirectFunctionality(httpClient, ro)
if ro.Context != nil {
req = req.WithContext(ro.Context)
}
if ro.BeforeRequest != nil {
if err := ro.BeforeRequest(req); err != nil {
return nil, err
}
}
return httpClient.Do(req)
} | [
"func",
"buildRequest",
"(",
"httpMethod",
",",
"url",
"string",
",",
"ro",
"*",
"RequestOptions",
",",
"httpClient",
"*",
"http",
".",
"Client",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"if",
"ro",
"==",
"nil",
"{",
"ro",
"=",... | // buildRequest is where most of the magic happens for request processing | [
"buildRequest",
"is",
"where",
"most",
"of",
"the",
"magic",
"happens",
"for",
"request",
"processing"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/request.go#L159-L210 |
151,283 | levigross/grequests | request.go | BuildHTTPClient | func BuildHTTPClient(ro RequestOptions) *http.Client {
if ro.HTTPClient != nil {
return ro.HTTPClient
}
// Does the user want to change the defaults?
if !ro.dontUseDefaultClient() {
return http.DefaultClient
}
// Using the user config for tls timeout or default
if ro.TLSHandshakeTimeout == 0 {
ro.TLSHandshakeTimeout = tlsHandshakeTimeout
}
// Using the user config for dial timeout or default
if ro.DialTimeout == 0 {
ro.DialTimeout = dialTimeout
}
// Using the user config for dial keep alive or default
if ro.DialKeepAlive == 0 {
ro.DialKeepAlive = dialKeepAlive
}
if ro.RequestTimeout == 0 {
ro.RequestTimeout = requestTimeout
}
var cookieJar http.CookieJar
if ro.UseCookieJar {
if ro.CookieJar != nil {
cookieJar = ro.CookieJar
} else {
// The function does not return an error ever... so we are just ignoring it
cookieJar, _ = cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
}
}
return &http.Client{
Jar: cookieJar,
Transport: createHTTPTransport(ro),
Timeout: ro.RequestTimeout,
}
} | go | func BuildHTTPClient(ro RequestOptions) *http.Client {
if ro.HTTPClient != nil {
return ro.HTTPClient
}
// Does the user want to change the defaults?
if !ro.dontUseDefaultClient() {
return http.DefaultClient
}
// Using the user config for tls timeout or default
if ro.TLSHandshakeTimeout == 0 {
ro.TLSHandshakeTimeout = tlsHandshakeTimeout
}
// Using the user config for dial timeout or default
if ro.DialTimeout == 0 {
ro.DialTimeout = dialTimeout
}
// Using the user config for dial keep alive or default
if ro.DialKeepAlive == 0 {
ro.DialKeepAlive = dialKeepAlive
}
if ro.RequestTimeout == 0 {
ro.RequestTimeout = requestTimeout
}
var cookieJar http.CookieJar
if ro.UseCookieJar {
if ro.CookieJar != nil {
cookieJar = ro.CookieJar
} else {
// The function does not return an error ever... so we are just ignoring it
cookieJar, _ = cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
}
}
return &http.Client{
Jar: cookieJar,
Transport: createHTTPTransport(ro),
Timeout: ro.RequestTimeout,
}
} | [
"func",
"BuildHTTPClient",
"(",
"ro",
"RequestOptions",
")",
"*",
"http",
".",
"Client",
"{",
"if",
"ro",
".",
"HTTPClient",
"!=",
"nil",
"{",
"return",
"ro",
".",
"HTTPClient",
"\n",
"}",
"\n\n",
"// Does the user want to change the defaults?",
"if",
"!",
"ro... | // BuildHTTPClient is a function that will return a custom HTTP client based on the request options provided
// the check is in UseDefaultClient | [
"BuildHTTPClient",
"is",
"a",
"function",
"that",
"will",
"return",
"a",
"custom",
"HTTP",
"client",
"based",
"on",
"the",
"request",
"options",
"provided",
"the",
"check",
"is",
"in",
"UseDefaultClient"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/request.go#L456-L502 |
151,284 | levigross/grequests | response.go | Read | func (r *Response) Read(p []byte) (n int, err error) {
if r.Error != nil {
return -1, r.Error
}
return r.RawResponse.Body.Read(p)
} | go | func (r *Response) Read(p []byte) (n int, err error) {
if r.Error != nil {
return -1, r.Error
}
return r.RawResponse.Body.Read(p)
} | [
"func",
"(",
"r",
"*",
"Response",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"r",
".",
"Error",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"r",
".",
"Error",
"\n",
"}",
"\n\n",
"retu... | // Read is part of our ability to support io.ReadCloser if someone wants to make use of the raw body | [
"Read",
"is",
"part",
"of",
"our",
"ability",
"to",
"support",
"io",
".",
"ReadCloser",
"if",
"someone",
"wants",
"to",
"make",
"use",
"of",
"the",
"raw",
"body"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/response.go#L55-L62 |
151,285 | levigross/grequests | response.go | Close | func (r *Response) Close() error {
if r.Error != nil {
return r.Error
}
io.Copy(ioutil.Discard, r)
return r.RawResponse.Body.Close()
} | go | func (r *Response) Close() error {
if r.Error != nil {
return r.Error
}
io.Copy(ioutil.Discard, r)
return r.RawResponse.Body.Close()
} | [
"func",
"(",
"r",
"*",
"Response",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"r",
".",
"Error",
"!=",
"nil",
"{",
"return",
"r",
".",
"Error",
"\n",
"}",
"\n\n",
"io",
".",
"Copy",
"(",
"ioutil",
".",
"Discard",
",",
"r",
")",
"\n\n",
"return... | // Close is part of our ability to support io.ReadCloser if someone wants to make use of the raw body | [
"Close",
"is",
"part",
"of",
"our",
"ability",
"to",
"support",
"io",
".",
"ReadCloser",
"if",
"someone",
"wants",
"to",
"make",
"use",
"of",
"the",
"raw",
"body"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/response.go#L65-L74 |
151,286 | levigross/grequests | response.go | DownloadToFile | func (r *Response) DownloadToFile(fileName string) error {
if r.Error != nil {
return r.Error
}
fd, err := os.Create(fileName)
if err != nil {
return err
}
defer r.Close() // This is a noop if we use the internal ByteBuffer
defer fd.Close()
if _, err := io.Copy(fd, r.getInternalReader()); err != nil && err != io.EOF {
return err
}
return nil
} | go | func (r *Response) DownloadToFile(fileName string) error {
if r.Error != nil {
return r.Error
}
fd, err := os.Create(fileName)
if err != nil {
return err
}
defer r.Close() // This is a noop if we use the internal ByteBuffer
defer fd.Close()
if _, err := io.Copy(fd, r.getInternalReader()); err != nil && err != io.EOF {
return err
}
return nil
} | [
"func",
"(",
"r",
"*",
"Response",
")",
"DownloadToFile",
"(",
"fileName",
"string",
")",
"error",
"{",
"if",
"r",
".",
"Error",
"!=",
"nil",
"{",
"return",
"r",
".",
"Error",
"\n",
"}",
"\n\n",
"fd",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"... | // DownloadToFile allows you to download the contents of the response to a file | [
"DownloadToFile",
"allows",
"you",
"to",
"download",
"the",
"contents",
"of",
"the",
"response",
"to",
"a",
"file"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/response.go#L77-L97 |
151,287 | levigross/grequests | response.go | JSON | func (r *Response) JSON(userStruct interface{}) error {
if r.Error != nil {
return r.Error
}
jsonDecoder := json.NewDecoder(r.getInternalReader())
defer r.Close()
return jsonDecoder.Decode(&userStruct)
} | go | func (r *Response) JSON(userStruct interface{}) error {
if r.Error != nil {
return r.Error
}
jsonDecoder := json.NewDecoder(r.getInternalReader())
defer r.Close()
return jsonDecoder.Decode(&userStruct)
} | [
"func",
"(",
"r",
"*",
"Response",
")",
"JSON",
"(",
"userStruct",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"r",
".",
"Error",
"!=",
"nil",
"{",
"return",
"r",
".",
"Error",
"\n",
"}",
"\n\n",
"jsonDecoder",
":=",
"json",
".",
"NewDecoder",
... | // JSON is a method that will populate a struct that is provided `userStruct` with the JSON returned within the
// response body | [
"JSON",
"is",
"a",
"method",
"that",
"will",
"populate",
"a",
"struct",
"that",
"is",
"provided",
"userStruct",
"with",
"the",
"JSON",
"returned",
"within",
"the",
"response",
"body"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/response.go#L130-L140 |
151,288 | levigross/grequests | response.go | String | func (r *Response) String() string {
if r.Error != nil {
return ""
}
r.populateResponseByteBuffer()
return r.internalByteBuffer.String()
} | go | func (r *Response) String() string {
if r.Error != nil {
return ""
}
r.populateResponseByteBuffer()
return r.internalByteBuffer.String()
} | [
"func",
"(",
"r",
"*",
"Response",
")",
"String",
"(",
")",
"string",
"{",
"if",
"r",
".",
"Error",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"r",
".",
"populateResponseByteBuffer",
"(",
")",
"\n\n",
"return",
"r",
".",
"internalByte... | // String returns the response as a string | [
"String",
"returns",
"the",
"response",
"as",
"a",
"string"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/response.go#L188-L196 |
151,289 | levigross/grequests | file_upload.go | FileUploadFromDisk | func FileUploadFromDisk(fileName string) ([]FileUpload, error) {
fd, err := os.Open(fileName)
if err != nil {
return nil, err
}
return []FileUpload{{FileContents: fd, FileName: fileName}}, nil
} | go | func FileUploadFromDisk(fileName string) ([]FileUpload, error) {
fd, err := os.Open(fileName)
if err != nil {
return nil, err
}
return []FileUpload{{FileContents: fd, FileName: fileName}}, nil
} | [
"func",
"FileUploadFromDisk",
"(",
"fileName",
"string",
")",
"(",
"[",
"]",
"FileUpload",
",",
"error",
")",
"{",
"fd",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"fileName",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
... | // FileUploadFromDisk allows you to create a FileUpload struct slice by just specifying a location on the disk | [
"FileUploadFromDisk",
"allows",
"you",
"to",
"create",
"a",
"FileUpload",
"struct",
"slice",
"by",
"just",
"specifying",
"a",
"location",
"on",
"the",
"disk"
] | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/file_upload.go#L28-L37 |
151,290 | levigross/grequests | file_upload.go | FileUploadFromGlob | func FileUploadFromGlob(fileSystemGlob string) ([]FileUpload, error) {
files, err := filepath.Glob(fileSystemGlob)
if err != nil {
return nil, err
}
if len(files) == 0 {
return nil, errors.New("grequests: No files have been returned in the glob")
}
filesToUpload := make([]FileUpload, 0, len(files))
for _, f := range files {
if s, err := os.Stat(f); err != nil || s.IsDir() {
continue
}
// ignoring error because I can stat the file
fd, _ := os.Open(f)
filesToUpload = append(filesToUpload, FileUpload{FileContents: fd, FileName: filepath.Base(fd.Name())})
}
return filesToUpload, nil
} | go | func FileUploadFromGlob(fileSystemGlob string) ([]FileUpload, error) {
files, err := filepath.Glob(fileSystemGlob)
if err != nil {
return nil, err
}
if len(files) == 0 {
return nil, errors.New("grequests: No files have been returned in the glob")
}
filesToUpload := make([]FileUpload, 0, len(files))
for _, f := range files {
if s, err := os.Stat(f); err != nil || s.IsDir() {
continue
}
// ignoring error because I can stat the file
fd, _ := os.Open(f)
filesToUpload = append(filesToUpload, FileUpload{FileContents: fd, FileName: filepath.Base(fd.Name())})
}
return filesToUpload, nil
} | [
"func",
"FileUploadFromGlob",
"(",
"fileSystemGlob",
"string",
")",
"(",
"[",
"]",
"FileUpload",
",",
"error",
")",
"{",
"files",
",",
"err",
":=",
"filepath",
".",
"Glob",
"(",
"fileSystemGlob",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil... | // FileUploadFromGlob allows you to create a FileUpload struct slice by just specifying a glob location on the disk
// this function will gloss over all errors in the files and only upload the files that don't return errors from the glob | [
"FileUploadFromGlob",
"allows",
"you",
"to",
"create",
"a",
"FileUpload",
"struct",
"slice",
"by",
"just",
"specifying",
"a",
"glob",
"location",
"on",
"the",
"disk",
"this",
"function",
"will",
"gloss",
"over",
"all",
"errors",
"in",
"the",
"files",
"and",
... | 37c80f76a0dae6ed656cbc830643ba53f45fc79c | https://github.com/levigross/grequests/blob/37c80f76a0dae6ed656cbc830643ba53f45fc79c/file_upload.go#L41-L68 |
151,291 | ahmetb/go-linq | orderby.go | OrderBy | func (q Query) OrderBy(selector func(interface{}) interface{}) OrderedQuery {
return OrderedQuery{
orders: []order{{selector: selector}},
original: q,
Query: Query{
Iterate: func() Iterator {
items := q.sort([]order{{selector: selector}})
len := len(items)
index := 0
return func() (item interface{}, ok bool) {
ok = index < len
if ok {
item = items[index]
index++
}
return
}
},
},
}
} | go | func (q Query) OrderBy(selector func(interface{}) interface{}) OrderedQuery {
return OrderedQuery{
orders: []order{{selector: selector}},
original: q,
Query: Query{
Iterate: func() Iterator {
items := q.sort([]order{{selector: selector}})
len := len(items)
index := 0
return func() (item interface{}, ok bool) {
ok = index < len
if ok {
item = items[index]
index++
}
return
}
},
},
}
} | [
"func",
"(",
"q",
"Query",
")",
"OrderBy",
"(",
"selector",
"func",
"(",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
")",
"OrderedQuery",
"{",
"return",
"OrderedQuery",
"{",
"orders",
":",
"[",
"]",
"order",
"{",
"{",
"selector",
":",
"selector"... | // OrderBy sorts the elements of a collection in ascending order. Elements are
// sorted according to a key. | [
"OrderBy",
"sorts",
"the",
"elements",
"of",
"a",
"collection",
"in",
"ascending",
"order",
".",
"Elements",
"are",
"sorted",
"according",
"to",
"a",
"key",
"."
] | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/orderby.go#L21-L43 |
151,292 | ahmetb/go-linq | orderby.go | ThenByDescending | func (oq OrderedQuery) ThenByDescending(selector func(interface{}) interface{}) OrderedQuery {
return OrderedQuery{
orders: append(oq.orders, order{selector: selector, desc: true}),
original: oq.original,
Query: Query{
Iterate: func() Iterator {
items := oq.original.sort(append(oq.orders, order{selector: selector, desc: true}))
len := len(items)
index := 0
return func() (item interface{}, ok bool) {
ok = index < len
if ok {
item = items[index]
index++
}
return
}
},
},
}
} | go | func (oq OrderedQuery) ThenByDescending(selector func(interface{}) interface{}) OrderedQuery {
return OrderedQuery{
orders: append(oq.orders, order{selector: selector, desc: true}),
original: oq.original,
Query: Query{
Iterate: func() Iterator {
items := oq.original.sort(append(oq.orders, order{selector: selector, desc: true}))
len := len(items)
index := 0
return func() (item interface{}, ok bool) {
ok = index < len
if ok {
item = items[index]
index++
}
return
}
},
},
}
} | [
"func",
"(",
"oq",
"OrderedQuery",
")",
"ThenByDescending",
"(",
"selector",
"func",
"(",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
")",
"OrderedQuery",
"{",
"return",
"OrderedQuery",
"{",
"orders",
":",
"append",
"(",
"oq",
".",
"orders",
",",
... | // ThenByDescending performs a subsequent ordering of the elements in a
// collection in descending order. This method enables you to specify multiple
// sort criteria by applying any number of ThenBy or ThenByDescending methods. | [
"ThenByDescending",
"performs",
"a",
"subsequent",
"ordering",
"of",
"the",
"elements",
"in",
"a",
"collection",
"in",
"descending",
"order",
".",
"This",
"method",
"enables",
"you",
"to",
"specify",
"multiple",
"sort",
"criteria",
"by",
"applying",
"any",
"numb... | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/orderby.go#L161-L183 |
151,293 | ahmetb/go-linq | orderby.go | Sort | func (q Query) Sort(less func(i, j interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
items := q.lessSort(less)
len := len(items)
index := 0
return func() (item interface{}, ok bool) {
ok = index < len
if ok {
item = items[index]
index++
}
return
}
},
}
} | go | func (q Query) Sort(less func(i, j interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
items := q.lessSort(less)
len := len(items)
index := 0
return func() (item interface{}, ok bool) {
ok = index < len
if ok {
item = items[index]
index++
}
return
}
},
}
} | [
"func",
"(",
"q",
"Query",
")",
"Sort",
"(",
"less",
"func",
"(",
"i",
",",
"j",
"interface",
"{",
"}",
")",
"bool",
")",
"Query",
"{",
"return",
"Query",
"{",
"Iterate",
":",
"func",
"(",
")",
"Iterator",
"{",
"items",
":=",
"q",
".",
"lessSort"... | // Sort returns a new query by sorting elements with provided less function in
// ascending order. The comparer function should return true if the parameter i
// is less than j. While this method is uglier than chaining OrderBy,
// OrderByDescending, ThenBy and ThenByDescending methods, it's performance is
// much better. | [
"Sort",
"returns",
"a",
"new",
"query",
"by",
"sorting",
"elements",
"with",
"provided",
"less",
"function",
"in",
"ascending",
"order",
".",
"The",
"comparer",
"function",
"should",
"return",
"true",
"if",
"the",
"parameter",
"i",
"is",
"less",
"than",
"j",... | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/orderby.go#L211-L229 |
151,294 | ahmetb/go-linq | join.go | Join | func (q Query) Join(inner Query,
outerKeySelector func(interface{}) interface{},
innerKeySelector func(interface{}) interface{},
resultSelector func(outer interface{}, inner interface{}) interface{}) Query {
return Query{
Iterate: func() Iterator {
outernext := q.Iterate()
innernext := inner.Iterate()
innerLookup := make(map[interface{}][]interface{})
for innerItem, ok := innernext(); ok; innerItem, ok = innernext() {
innerKey := innerKeySelector(innerItem)
innerLookup[innerKey] = append(innerLookup[innerKey], innerItem)
}
var outerItem interface{}
var innerGroup []interface{}
innerLen, innerIndex := 0, 0
return func() (item interface{}, ok bool) {
if innerIndex >= innerLen {
has := false
for !has {
outerItem, ok = outernext()
if !ok {
return
}
innerGroup, has = innerLookup[outerKeySelector(outerItem)]
innerLen = len(innerGroup)
innerIndex = 0
}
}
item = resultSelector(outerItem, innerGroup[innerIndex])
innerIndex++
return item, true
}
},
}
} | go | func (q Query) Join(inner Query,
outerKeySelector func(interface{}) interface{},
innerKeySelector func(interface{}) interface{},
resultSelector func(outer interface{}, inner interface{}) interface{}) Query {
return Query{
Iterate: func() Iterator {
outernext := q.Iterate()
innernext := inner.Iterate()
innerLookup := make(map[interface{}][]interface{})
for innerItem, ok := innernext(); ok; innerItem, ok = innernext() {
innerKey := innerKeySelector(innerItem)
innerLookup[innerKey] = append(innerLookup[innerKey], innerItem)
}
var outerItem interface{}
var innerGroup []interface{}
innerLen, innerIndex := 0, 0
return func() (item interface{}, ok bool) {
if innerIndex >= innerLen {
has := false
for !has {
outerItem, ok = outernext()
if !ok {
return
}
innerGroup, has = innerLookup[outerKeySelector(outerItem)]
innerLen = len(innerGroup)
innerIndex = 0
}
}
item = resultSelector(outerItem, innerGroup[innerIndex])
innerIndex++
return item, true
}
},
}
} | [
"func",
"(",
"q",
"Query",
")",
"Join",
"(",
"inner",
"Query",
",",
"outerKeySelector",
"func",
"(",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
",",
"innerKeySelector",
"func",
"(",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
",",
"resul... | // Join correlates the elements of two collection based on matching keys.
//
// A join refers to the operation of correlating the elements of two sources of
// information based on a common key. Join brings the two information sources
// and the keys by which they are matched together in one method call. This
// differs from the use of SelectMany, which requires more than one method call
// to perform the same operation.
//
// Join preserves the order of the elements of outer collection, and for each of
// these elements, the order of the matching elements of inner. | [
"Join",
"correlates",
"the",
"elements",
"of",
"two",
"collection",
"based",
"on",
"matching",
"keys",
".",
"A",
"join",
"refers",
"to",
"the",
"operation",
"of",
"correlating",
"the",
"elements",
"of",
"two",
"sources",
"of",
"information",
"based",
"on",
"... | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/join.go#L13-L54 |
151,295 | ahmetb/go-linq | skip.go | Skip | func (q Query) Skip(count int) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
n := count
return func() (item interface{}, ok bool) {
for ; n > 0; n-- {
item, ok = next()
if !ok {
return
}
}
return next()
}
},
}
} | go | func (q Query) Skip(count int) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
n := count
return func() (item interface{}, ok bool) {
for ; n > 0; n-- {
item, ok = next()
if !ok {
return
}
}
return next()
}
},
}
} | [
"func",
"(",
"q",
"Query",
")",
"Skip",
"(",
"count",
"int",
")",
"Query",
"{",
"return",
"Query",
"{",
"Iterate",
":",
"func",
"(",
")",
"Iterator",
"{",
"next",
":=",
"q",
".",
"Iterate",
"(",
")",
"\n",
"n",
":=",
"count",
"\n\n",
"return",
"f... | // Skip bypasses a specified number of elements in a collection and then returns
// the remaining elements. | [
"Skip",
"bypasses",
"a",
"specified",
"number",
"of",
"elements",
"in",
"a",
"collection",
"and",
"then",
"returns",
"the",
"remaining",
"elements",
"."
] | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/skip.go#L5-L23 |
151,296 | ahmetb/go-linq | skip.go | SkipWhile | func (q Query) SkipWhile(predicate func(interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
ready := false
return func() (item interface{}, ok bool) {
for !ready {
item, ok = next()
if !ok {
return
}
ready = !predicate(item)
if ready {
return
}
}
return next()
}
},
}
} | go | func (q Query) SkipWhile(predicate func(interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
ready := false
return func() (item interface{}, ok bool) {
for !ready {
item, ok = next()
if !ok {
return
}
ready = !predicate(item)
if ready {
return
}
}
return next()
}
},
}
} | [
"func",
"(",
"q",
"Query",
")",
"SkipWhile",
"(",
"predicate",
"func",
"(",
"interface",
"{",
"}",
")",
"bool",
")",
"Query",
"{",
"return",
"Query",
"{",
"Iterate",
":",
"func",
"(",
")",
"Iterator",
"{",
"next",
":=",
"q",
".",
"Iterate",
"(",
")... | // SkipWhile bypasses elements in a collection as long as a specified condition
// is true and then returns the remaining elements.
//
// This method tests each element by using predicate and skips the element if
// the result is true. After the predicate function returns false for an
// element, that element and the remaining elements in source are returned and
// there are no more invocations of predicate. | [
"SkipWhile",
"bypasses",
"elements",
"in",
"a",
"collection",
"as",
"long",
"as",
"a",
"specified",
"condition",
"is",
"true",
"and",
"then",
"returns",
"the",
"remaining",
"elements",
".",
"This",
"method",
"tests",
"each",
"element",
"by",
"using",
"predicat... | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/skip.go#L32-L55 |
151,297 | ahmetb/go-linq | skip.go | SkipWhileIndexed | func (q Query) SkipWhileIndexed(predicate func(int, interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
ready := false
index := 0
return func() (item interface{}, ok bool) {
for !ready {
item, ok = next()
if !ok {
return
}
ready = !predicate(index, item)
if ready {
return
}
index++
}
return next()
}
},
}
} | go | func (q Query) SkipWhileIndexed(predicate func(int, interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
ready := false
index := 0
return func() (item interface{}, ok bool) {
for !ready {
item, ok = next()
if !ok {
return
}
ready = !predicate(index, item)
if ready {
return
}
index++
}
return next()
}
},
}
} | [
"func",
"(",
"q",
"Query",
")",
"SkipWhileIndexed",
"(",
"predicate",
"func",
"(",
"int",
",",
"interface",
"{",
"}",
")",
"bool",
")",
"Query",
"{",
"return",
"Query",
"{",
"Iterate",
":",
"func",
"(",
")",
"Iterator",
"{",
"next",
":=",
"q",
".",
... | // SkipWhileIndexed bypasses elements in a collection as long as a specified
// condition is true and then returns the remaining elements. The element's
// index is used in the logic of the predicate function.
//
// This method tests each element by using predicate and skips the element if
// the result is true. After the predicate function returns false for an
// element, that element and the remaining elements in source are returned and
// there are no more invocations of predicate. | [
"SkipWhileIndexed",
"bypasses",
"elements",
"in",
"a",
"collection",
"as",
"long",
"as",
"a",
"specified",
"condition",
"is",
"true",
"and",
"then",
"returns",
"the",
"remaining",
"elements",
".",
"The",
"element",
"s",
"index",
"is",
"used",
"in",
"the",
"l... | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/skip.go#L87-L113 |
151,298 | ahmetb/go-linq | take.go | TakeWhile | func (q Query) TakeWhile(predicate func(interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
done := false
return func() (item interface{}, ok bool) {
if done {
return
}
item, ok = next()
if !ok {
done = true
return
}
if predicate(item) {
return
}
done = true
return nil, false
}
},
}
} | go | func (q Query) TakeWhile(predicate func(interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
done := false
return func() (item interface{}, ok bool) {
if done {
return
}
item, ok = next()
if !ok {
done = true
return
}
if predicate(item) {
return
}
done = true
return nil, false
}
},
}
} | [
"func",
"(",
"q",
"Query",
")",
"TakeWhile",
"(",
"predicate",
"func",
"(",
"interface",
"{",
"}",
")",
"bool",
")",
"Query",
"{",
"return",
"Query",
"{",
"Iterate",
":",
"func",
"(",
")",
"Iterator",
"{",
"next",
":=",
"q",
".",
"Iterate",
"(",
")... | // TakeWhile returns elements from a collection as long as a specified condition
// is true, and then skips the remaining elements. | [
"TakeWhile",
"returns",
"elements",
"from",
"a",
"collection",
"as",
"long",
"as",
"a",
"specified",
"condition",
"is",
"true",
"and",
"then",
"skips",
"the",
"remaining",
"elements",
"."
] | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/take.go#L25-L51 |
151,299 | ahmetb/go-linq | take.go | TakeWhileIndexed | func (q Query) TakeWhileIndexed(predicate func(int, interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
done := false
index := 0
return func() (item interface{}, ok bool) {
if done {
return
}
item, ok = next()
if !ok {
done = true
return
}
if predicate(index, item) {
index++
return
}
done = true
return nil, false
}
},
}
} | go | func (q Query) TakeWhileIndexed(predicate func(int, interface{}) bool) Query {
return Query{
Iterate: func() Iterator {
next := q.Iterate()
done := false
index := 0
return func() (item interface{}, ok bool) {
if done {
return
}
item, ok = next()
if !ok {
done = true
return
}
if predicate(index, item) {
index++
return
}
done = true
return nil, false
}
},
}
} | [
"func",
"(",
"q",
"Query",
")",
"TakeWhileIndexed",
"(",
"predicate",
"func",
"(",
"int",
",",
"interface",
"{",
"}",
")",
"bool",
")",
"Query",
"{",
"return",
"Query",
"{",
"Iterate",
":",
"func",
"(",
")",
"Iterator",
"{",
"next",
":=",
"q",
".",
... | // TakeWhileIndexed returns elements from a collection as long as a specified
// condition is true. The element's index is used in the logic of the predicate
// function. The first argument of predicate represents the zero-based index of
// the element within collection. The second argument represents the element to
// test. | [
"TakeWhileIndexed",
"returns",
"elements",
"from",
"a",
"collection",
"as",
"long",
"as",
"a",
"specified",
"condition",
"is",
"true",
".",
"The",
"element",
"s",
"index",
"is",
"used",
"in",
"the",
"logic",
"of",
"the",
"predicate",
"function",
".",
"The",
... | 9f6960b5d2e017ec4b7820f045fbd7db66dd53b6 | https://github.com/ahmetb/go-linq/blob/9f6960b5d2e017ec4b7820f045fbd7db66dd53b6/take.go#L80-L108 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.