id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
140,400 | signalfx/gateway | main.go | closeForwarders | func closeForwarders(forwarders []protocol.Forwarder) []error {
errs := make([]error, len(forwarders))
wg := sync.WaitGroup{}
wg.Add(len(forwarders))
for index, f := range forwarders {
go func(index int, f protocol.Forwarder, errs []error) {
errs[index] = f.Close()
wg.Done()
}(index, f, errs)
}
wg.Wait(... | go | func closeForwarders(forwarders []protocol.Forwarder) []error {
errs := make([]error, len(forwarders))
wg := sync.WaitGroup{}
wg.Add(len(forwarders))
for index, f := range forwarders {
go func(index int, f protocol.Forwarder, errs []error) {
errs[index] = f.Close()
wg.Done()
}(index, f, errs)
}
wg.Wait(... | [
"func",
"closeForwarders",
"(",
"forwarders",
"[",
"]",
"protocol",
".",
"Forwarder",
")",
"[",
"]",
"error",
"{",
"errs",
":=",
"make",
"(",
"[",
"]",
"error",
",",
"len",
"(",
"forwarders",
")",
")",
"\n",
"wg",
":=",
"sync",
".",
"WaitGroup",
"{",... | // closeForwarders concurrently close and drain all of the forwarders | [
"closeForwarders",
"concurrently",
"close",
"and",
"drain",
"all",
"of",
"the",
"forwarders"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L379-L391 |
140,401 | signalfx/gateway | main.go | waitForForwardersToDrain | func (p *gateway) waitForForwardersToDrain(ctx context.Context, startTime time.Time) {
p.logger.Log("Waiting for connections to drain")
for {
select {
case <-ctx.Done():
if totalPipeline := p.Pipeline(); totalPipeline != 0 {
p.logger.Log(logkey.TotalPipeline, totalPipeline, "Connections never drained. Thi... | go | func (p *gateway) waitForForwardersToDrain(ctx context.Context, startTime time.Time) {
p.logger.Log("Waiting for connections to drain")
for {
select {
case <-ctx.Done():
if totalPipeline := p.Pipeline(); totalPipeline != 0 {
p.logger.Log(logkey.TotalPipeline, totalPipeline, "Connections never drained. Thi... | [
"func",
"(",
"p",
"*",
"gateway",
")",
"waitForForwardersToDrain",
"(",
"ctx",
"context",
".",
"Context",
",",
"startTime",
"time",
".",
"Time",
")",
"{",
"p",
".",
"logger",
".",
"Log",
"(",
"\"",
"\"",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
... | // waitForForwardersToDrain waits for the pipeline of inflight things to drain across all forwarders
// or for the context to expire. The passed in context should be the graceful shutdown timeout context.
// It should be cancelled when this function exceeds the configured graceful timeout duration | [
"waitForForwardersToDrain",
"waits",
"for",
"the",
"pipeline",
"of",
"inflight",
"things",
"to",
"drain",
"across",
"all",
"forwarders",
"or",
"for",
"the",
"context",
"to",
"expire",
".",
"The",
"passed",
"in",
"context",
"should",
"be",
"the",
"graceful",
"s... | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L396-L415 |
140,402 | signalfx/gateway | main.go | GetContext | func GetContext(ctx context.Context) context.Context {
if ctx != nil {
return ctx
}
return context.Background()
} | go | func GetContext(ctx context.Context) context.Context {
if ctx != nil {
return ctx
}
return context.Background()
} | [
"func",
"GetContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"context",
".",
"Context",
"{",
"if",
"ctx",
"!=",
"nil",
"{",
"return",
"ctx",
"\n",
"}",
"\n",
"return",
"context",
".",
"Background",
"(",
")",
"\n",
"}"
] | // GetContext returns the context passed in or creates a background context if the context passed in is nil | [
"GetContext",
"returns",
"the",
"context",
"passed",
"in",
"or",
"creates",
"a",
"background",
"context",
"if",
"the",
"context",
"passed",
"in",
"is",
"nil"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L418-L423 |
140,403 | signalfx/gateway | main.go | stop | func (p *gateway) stop(ctx context.Context) (err error) {
startTime := p.tk.Now() // keeps track of the time when graceful shutdown began
p.logger.Log("Starting graceful shutdown")
errs := make([]error, len(p.listeners)+len(p.forwarders)+1)
// close health checks on all first
closeListenerHealthChecks(p.listener... | go | func (p *gateway) stop(ctx context.Context) (err error) {
startTime := p.tk.Now() // keeps track of the time when graceful shutdown began
p.logger.Log("Starting graceful shutdown")
errs := make([]error, len(p.listeners)+len(p.forwarders)+1)
// close health checks on all first
closeListenerHealthChecks(p.listener... | [
"func",
"(",
"p",
"*",
"gateway",
")",
"stop",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"err",
"error",
")",
"{",
"startTime",
":=",
"p",
".",
"tk",
".",
"Now",
"(",
")",
"// keeps track of the time when graceful shutdown began",
"\n",
"p",
".",
... | // Stop shutsdown a running gateway and utilizes the graceful shutdown timeout | [
"Stop",
"shutsdown",
"a",
"running",
"gateway",
"and",
"utilizes",
"the",
"graceful",
"shutdown",
"timeout"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L434-L493 |
140,404 | signalfx/gateway | main.go | Pipeline | func (p *gateway) Pipeline() int64 {
var totalForwarded int64
for _, f := range p.forwarders {
totalForwarded += f.Pipeline()
}
return totalForwarded
} | go | func (p *gateway) Pipeline() int64 {
var totalForwarded int64
for _, f := range p.forwarders {
totalForwarded += f.Pipeline()
}
return totalForwarded
} | [
"func",
"(",
"p",
"*",
"gateway",
")",
"Pipeline",
"(",
")",
"int64",
"{",
"var",
"totalForwarded",
"int64",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"p",
".",
"forwarders",
"{",
"totalForwarded",
"+=",
"f",
".",
"Pipeline",
"(",
")",
"\n",
"}",
... | // Pipeline returns the number of items in flight that need to be drained across all configured forwarders | [
"Pipeline",
"returns",
"the",
"number",
"of",
"items",
"in",
"flight",
"that",
"need",
"to",
"be",
"drained",
"across",
"all",
"configured",
"forwarders"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L496-L502 |
140,405 | signalfx/gateway | main.go | configure | func (p *gateway) configure(loadedConfig *config.GatewayConfig) error {
if loadedConfig == nil {
return fmt.Errorf("unable to configure gateway with nil config")
}
// save config to the gateway
p.config = loadedConfig
// set debug context from loaded config
if loadedConfig.DebugFlag != nil && *loadedConfig.Deb... | go | func (p *gateway) configure(loadedConfig *config.GatewayConfig) error {
if loadedConfig == nil {
return fmt.Errorf("unable to configure gateway with nil config")
}
// save config to the gateway
p.config = loadedConfig
// set debug context from loaded config
if loadedConfig.DebugFlag != nil && *loadedConfig.Deb... | [
"func",
"(",
"p",
"*",
"gateway",
")",
"configure",
"(",
"loadedConfig",
"*",
"config",
".",
"GatewayConfig",
")",
"error",
"{",
"if",
"loadedConfig",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// save con... | // takes a gateway config and configures the gateway with it | [
"takes",
"a",
"gateway",
"config",
"and",
"configures",
"the",
"gateway",
"with",
"it"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L505-L538 |
140,406 | signalfx/gateway | main.go | setupEtcdClient | func (p *gateway) setupEtcdClient(etcdCfg *embetcd.Config) (err error) {
var endpoints []string
if etcdCfg.ClusterState == embed.ClusterStateFlagNew {
endpoints = embetcd.URLSToStringSlice(etcdCfg.ACUrls)
} else {
endpoints = etcdCfg.InitialCluster
}
// setup the etcd client
if etcdCfg.ClusterName != "" && le... | go | func (p *gateway) setupEtcdClient(etcdCfg *embetcd.Config) (err error) {
var endpoints []string
if etcdCfg.ClusterState == embed.ClusterStateFlagNew {
endpoints = embetcd.URLSToStringSlice(etcdCfg.ACUrls)
} else {
endpoints = etcdCfg.InitialCluster
}
// setup the etcd client
if etcdCfg.ClusterName != "" && le... | [
"func",
"(",
"p",
"*",
"gateway",
")",
"setupEtcdClient",
"(",
"etcdCfg",
"*",
"embetcd",
".",
"Config",
")",
"(",
"err",
"error",
")",
"{",
"var",
"endpoints",
"[",
"]",
"string",
"\n",
"if",
"etcdCfg",
".",
"ClusterState",
"==",
"embed",
".",
"Cluste... | // setupEtcdClient sets up the etcd client on the gateway | [
"setupEtcdClient",
"sets",
"up",
"the",
"etcd",
"client",
"on",
"the",
"gateway"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L704-L720 |
140,407 | signalfx/gateway | main.go | setupEtcdServer | func (p *gateway) setupEtcdServer(ctx context.Context, etcdCfg *embetcd.Config) (err error) {
// if the cluster op is invalid short circuit and return
if !(etcdCfg.ClusterState == embed.ClusterStateFlagExisting || etcdCfg.ClusterState == embed.ClusterStateFlagNew || etcdCfg.ClusterState == "") {
return fmt.Errorf("... | go | func (p *gateway) setupEtcdServer(ctx context.Context, etcdCfg *embetcd.Config) (err error) {
// if the cluster op is invalid short circuit and return
if !(etcdCfg.ClusterState == embed.ClusterStateFlagExisting || etcdCfg.ClusterState == embed.ClusterStateFlagNew || etcdCfg.ClusterState == "") {
return fmt.Errorf("... | [
"func",
"(",
"p",
"*",
"gateway",
")",
"setupEtcdServer",
"(",
"ctx",
"context",
".",
"Context",
",",
"etcdCfg",
"*",
"embetcd",
".",
"Config",
")",
"(",
"err",
"error",
")",
"{",
"// if the cluster op is invalid short circuit and return",
"if",
"!",
"(",
"etc... | // setupEtcdServer sets up the etcd server on the gateway | [
"setupEtcdServer",
"sets",
"up",
"the",
"etcd",
"server",
"on",
"the",
"gateway"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L723-L740 |
140,408 | signalfx/gateway | main.go | setupEtcd | func (p *gateway) setupEtcd(ctx context.Context, loadedConfig *config.GatewayConfig) error {
// short circuit if there is no cluster operation defined because that means we're running in non-cluster mode
// This IS NOT an error state!
if loadedConfig.ClusterOperation == nil || *loadedConfig.ClusterOperation == "" {
... | go | func (p *gateway) setupEtcd(ctx context.Context, loadedConfig *config.GatewayConfig) error {
// short circuit if there is no cluster operation defined because that means we're running in non-cluster mode
// This IS NOT an error state!
if loadedConfig.ClusterOperation == nil || *loadedConfig.ClusterOperation == "" {
... | [
"func",
"(",
"p",
"*",
"gateway",
")",
"setupEtcd",
"(",
"ctx",
"context",
".",
"Context",
",",
"loadedConfig",
"*",
"config",
".",
"GatewayConfig",
")",
"error",
"{",
"// short circuit if there is no cluster operation defined because that means we're running in non-cluster... | // setupEtcd sets up the etcd server and client if applicable and returns errors if there's any problems | [
"setupEtcd",
"sets",
"up",
"the",
"etcd",
"server",
"and",
"client",
"if",
"applicable",
"and",
"returns",
"errors",
"if",
"there",
"s",
"any",
"problems"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L743-L792 |
140,409 | signalfx/gateway | main.go | runningLoop | func (p *gateway) runningLoop(ctx context.Context) (err error) {
// getEtcdStopCh returns the gateway's etcd server's stop notify channel or returns a blocking channel if etcd is nil
getEtcdStopCh := func() <-chan struct{} {
if p.etcdServer != nil && p.etcdServer.Server != nil {
return p.etcdServer.Server.StopNo... | go | func (p *gateway) runningLoop(ctx context.Context) (err error) {
// getEtcdStopCh returns the gateway's etcd server's stop notify channel or returns a blocking channel if etcd is nil
getEtcdStopCh := func() <-chan struct{} {
if p.etcdServer != nil && p.etcdServer.Server != nil {
return p.etcdServer.Server.StopNo... | [
"func",
"(",
"p",
"*",
"gateway",
")",
"runningLoop",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"err",
"error",
")",
"{",
"// getEtcdStopCh returns the gateway's etcd server's stop notify channel or returns a blocking channel if etcd is nil",
"getEtcdStopCh",
":=",
"... | // runningLoop is the where we block in the main gateway routine | [
"runningLoop",
"is",
"the",
"where",
"we",
"block",
"in",
"the",
"main",
"gateway",
"routine"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L795-L819 |
140,410 | signalfx/gateway | main.go | loadConfig | func loadConfig(configFilePath string, logger log.Logger) (*config.GatewayConfig, error) {
logger.Log(logkey.ConfigFile, configFilePath, "Looking for config file")
logger.Log(logkey.Env, strings.Join(os.Environ(), "-"), "Looking for config file")
// load the config file
loadedConfig, err := config.Load(configFileP... | go | func loadConfig(configFilePath string, logger log.Logger) (*config.GatewayConfig, error) {
logger.Log(logkey.ConfigFile, configFilePath, "Looking for config file")
logger.Log(logkey.Env, strings.Join(os.Environ(), "-"), "Looking for config file")
// load the config file
loadedConfig, err := config.Load(configFileP... | [
"func",
"loadConfig",
"(",
"configFilePath",
"string",
",",
"logger",
"log",
".",
"Logger",
")",
"(",
"*",
"config",
".",
"GatewayConfig",
",",
"error",
")",
"{",
"logger",
".",
"Log",
"(",
"logkey",
".",
"ConfigFile",
",",
"configFilePath",
",",
"\"",
"... | // loadConfig loads a config file for the Gateway, the returned error
// is used for testing and should be refactored out later | [
"loadConfig",
"loads",
"a",
"config",
"file",
"for",
"the",
"Gateway",
"the",
"returned",
"error",
"is",
"used",
"for",
"testing",
"and",
"should",
"be",
"refactored",
"out",
"later"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L882-L904 |
140,411 | signalfx/gateway | main.go | writePidFile | func writePidFile(loadedConfig *config.GatewayConfig, logger log.Logger) {
if loadedConfig != nil {
pid := os.Getpid()
if err := ioutil.WriteFile(*loadedConfig.PidFilename, []byte(strconv.FormatInt(int64(pid), 10)), os.FileMode(0644)); err != nil {
logger.Log(log.Err, err, logkey.Filename, *loadedConfig.PidFile... | go | func writePidFile(loadedConfig *config.GatewayConfig, logger log.Logger) {
if loadedConfig != nil {
pid := os.Getpid()
if err := ioutil.WriteFile(*loadedConfig.PidFilename, []byte(strconv.FormatInt(int64(pid), 10)), os.FileMode(0644)); err != nil {
logger.Log(log.Err, err, logkey.Filename, *loadedConfig.PidFile... | [
"func",
"writePidFile",
"(",
"loadedConfig",
"*",
"config",
".",
"GatewayConfig",
",",
"logger",
"log",
".",
"Logger",
")",
"{",
"if",
"loadedConfig",
"!=",
"nil",
"{",
"pid",
":=",
"os",
".",
"Getpid",
"(",
")",
"\n",
"if",
"err",
":=",
"ioutil",
".",... | // writePidFile writes the pid file for the gateway server | [
"writePidFile",
"writes",
"the",
"pid",
"file",
"for",
"the",
"gateway",
"server"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L917-L924 |
140,412 | signalfx/gateway | main.go | removePidFile | func removePidFile(loadedConfig *config.GatewayConfig, logger log.Logger) {
if loadedConfig != nil {
log.IfErr(logger, os.Remove(*loadedConfig.PidFilename))
}
} | go | func removePidFile(loadedConfig *config.GatewayConfig, logger log.Logger) {
if loadedConfig != nil {
log.IfErr(logger, os.Remove(*loadedConfig.PidFilename))
}
} | [
"func",
"removePidFile",
"(",
"loadedConfig",
"*",
"config",
".",
"GatewayConfig",
",",
"logger",
"log",
".",
"Logger",
")",
"{",
"if",
"loadedConfig",
"!=",
"nil",
"{",
"log",
".",
"IfErr",
"(",
"logger",
",",
"os",
".",
"Remove",
"(",
"*",
"loadedConfi... | // removePidFile removes the pid file for the gateway server | [
"removePidFile",
"removes",
"the",
"pid",
"file",
"for",
"the",
"gateway",
"server"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L927-L931 |
140,413 | signalfx/gateway | main.go | main | func main() {
// create a logger before we load config
// TODO: make logger a package variable so we don't have to pass it around
logger := log.NewContext(log.DefaultLogger.CreateChild()).With(logkey.Time, log.DefaultTimestamp, logkey.Caller, log.DefaultCaller)
// parse runtime flags only once
flagParse()
// in... | go | func main() {
// create a logger before we load config
// TODO: make logger a package variable so we don't have to pass it around
logger := log.NewContext(log.DefaultLogger.CreateChild()).With(logkey.Time, log.DefaultTimestamp, logkey.Caller, log.DefaultCaller)
// parse runtime flags only once
flagParse()
// in... | [
"func",
"main",
"(",
")",
"{",
"// create a logger before we load config",
"// TODO: make logger a package variable so we don't have to pass it around",
"logger",
":=",
"log",
".",
"NewContext",
"(",
"log",
".",
"DefaultLogger",
".",
"CreateChild",
"(",
")",
")",
".",
"Wi... | // main function for gateway server | [
"main",
"function",
"for",
"gateway",
"server"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L934-L970 |
140,414 | signalfx/gateway | main.go | FirstNonNil | func FirstNonNil(errs ...error) error {
for _, err := range errs {
if err != nil {
return err
}
}
return nil
} | go | func FirstNonNil(errs ...error) error {
for _, err := range errs {
if err != nil {
return err
}
}
return nil
} | [
"func",
"FirstNonNil",
"(",
"errs",
"...",
"error",
")",
"error",
"{",
"for",
"_",
",",
"err",
":=",
"range",
"errs",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // FirstNonNil returns what it says it does | [
"FirstNonNil",
"returns",
"what",
"it",
"says",
"it",
"does"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/main.go#L973-L980 |
140,415 | signalfx/gateway | protocol/signalfx/signalfxforwarder.go | NewForwarder | func NewForwarder(conf *ForwarderConfig) (ret *Forwarder, err error) {
conf = pointer.FillDefaultFrom(conf, defaultForwarderConfig).(*ForwarderConfig)
tr := &http.Transport{
Proxy: http.ProxyFromEnvironment,
MaxIdleConnsPerHost: int(*conf.MaxIdleConns * 2),
ResponseHeaderTimeout: *conf.Timeout... | go | func NewForwarder(conf *ForwarderConfig) (ret *Forwarder, err error) {
conf = pointer.FillDefaultFrom(conf, defaultForwarderConfig).(*ForwarderConfig)
tr := &http.Transport{
Proxy: http.ProxyFromEnvironment,
MaxIdleConnsPerHost: int(*conf.MaxIdleConns * 2),
ResponseHeaderTimeout: *conf.Timeout... | [
"func",
"NewForwarder",
"(",
"conf",
"*",
"ForwarderConfig",
")",
"(",
"ret",
"*",
"Forwarder",
",",
"err",
"error",
")",
"{",
"conf",
"=",
"pointer",
".",
"FillDefaultFrom",
"(",
"conf",
",",
"defaultForwarderConfig",
")",
".",
"(",
"*",
"ForwarderConfig",
... | // NewForwarder creates a new JSON forwarder | [
"NewForwarder",
"creates",
"a",
"new",
"JSON",
"forwarder"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxforwarder.go#L88-L138 |
140,416 | signalfx/gateway | protocol/signalfx/signalfxforwarder.go | Datapoints | func (connector *Forwarder) Datapoints() []*datapoint.Datapoint {
dps := connector.stats.requests.Datapoints()
dps = append(dps, connector.stats.drainSize.Datapoints()...)
dps = append(dps, connector.GetFilteredDatapoints()...)
dps = append(dps, connector.sampler.Datapoints()...)
return dps
} | go | func (connector *Forwarder) Datapoints() []*datapoint.Datapoint {
dps := connector.stats.requests.Datapoints()
dps = append(dps, connector.stats.drainSize.Datapoints()...)
dps = append(dps, connector.GetFilteredDatapoints()...)
dps = append(dps, connector.sampler.Datapoints()...)
return dps
} | [
"func",
"(",
"connector",
"*",
"Forwarder",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"dps",
":=",
"connector",
".",
"stats",
".",
"requests",
".",
"Datapoints",
"(",
")",
"\n",
"dps",
"=",
"append",
"(",
"dps",
... | // Datapoints returns datapoints | [
"Datapoints",
"returns",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxforwarder.go#L141-L147 |
140,417 | signalfx/gateway | protocol/signalfx/signalfxforwarder.go | Close | func (connector *Forwarder) Close() error {
connector.tr.CloseIdleConnections()
return connector.sampler.Close()
} | go | func (connector *Forwarder) Close() error {
connector.tr.CloseIdleConnections()
return connector.sampler.Close()
} | [
"func",
"(",
"connector",
"*",
"Forwarder",
")",
"Close",
"(",
")",
"error",
"{",
"connector",
".",
"tr",
".",
"CloseIdleConnections",
"(",
")",
"\n",
"return",
"connector",
".",
"sampler",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Close will terminate idle HTTP client connections | [
"Close",
"will",
"terminate",
"idle",
"HTTP",
"client",
"connections"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxforwarder.go#L150-L153 |
140,418 | signalfx/gateway | protocol/signalfx/signalfxforwarder.go | AddDatapoints | func (connector *Forwarder) AddDatapoints(ctx context.Context, datapoints []*datapoint.Datapoint) error {
start := time.Now()
atomic.AddInt64(&connector.stats.pipeline, int64(len(datapoints)))
defer atomic.AddInt64(&connector.stats.pipeline, -int64(len(datapoints)))
defer connector.stats.requests.Add(float64(time.N... | go | func (connector *Forwarder) AddDatapoints(ctx context.Context, datapoints []*datapoint.Datapoint) error {
start := time.Now()
atomic.AddInt64(&connector.stats.pipeline, int64(len(datapoints)))
defer atomic.AddInt64(&connector.stats.pipeline, -int64(len(datapoints)))
defer connector.stats.requests.Add(float64(time.N... | [
"func",
"(",
"connector",
"*",
"Forwarder",
")",
"AddDatapoints",
"(",
"ctx",
"context",
".",
"Context",
",",
"datapoints",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"error",
"{",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"atomic",
".... | // AddDatapoints forwards datapoints to SignalFx | [
"AddDatapoints",
"forwards",
"datapoints",
"to",
"SignalFx"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxforwarder.go#L159-L172 |
140,419 | signalfx/gateway | protocol/signalfx/signalfxforwarder.go | AddEvents | func (connector *Forwarder) AddEvents(ctx context.Context, events []*event.Event) error {
atomic.AddInt64(&connector.stats.pipeline, int64(len(events)))
defer atomic.AddInt64(&connector.stats.pipeline, -int64(len(events)))
atomic.AddInt64(&connector.stats.totalEventsForwarded, int64(len(events)))
// could filter he... | go | func (connector *Forwarder) AddEvents(ctx context.Context, events []*event.Event) error {
atomic.AddInt64(&connector.stats.pipeline, int64(len(events)))
defer atomic.AddInt64(&connector.stats.pipeline, -int64(len(events)))
atomic.AddInt64(&connector.stats.totalEventsForwarded, int64(len(events)))
// could filter he... | [
"func",
"(",
"connector",
"*",
"Forwarder",
")",
"AddEvents",
"(",
"ctx",
"context",
".",
"Context",
",",
"events",
"[",
"]",
"*",
"event",
".",
"Event",
")",
"error",
"{",
"atomic",
".",
"AddInt64",
"(",
"&",
"connector",
".",
"stats",
".",
"pipeline"... | // AddEvents forwards events to SignalFx | [
"AddEvents",
"forwards",
"events",
"to",
"SignalFx"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxforwarder.go#L175-L184 |
140,420 | signalfx/gateway | protocol/signalfx/signalfxforwarder.go | AddSpans | func (connector *Forwarder) AddSpans(ctx context.Context, spans []*trace.Span) error {
atomic.AddInt64(&connector.stats.pipeline, int64(len(spans)))
defer atomic.AddInt64(&connector.stats.pipeline, -int64(len(spans)))
atomic.AddInt64(&connector.stats.totalSpansForwarded, int64(len(spans)))
// could filter here
if ... | go | func (connector *Forwarder) AddSpans(ctx context.Context, spans []*trace.Span) error {
atomic.AddInt64(&connector.stats.pipeline, int64(len(spans)))
defer atomic.AddInt64(&connector.stats.pipeline, -int64(len(spans)))
atomic.AddInt64(&connector.stats.totalSpansForwarded, int64(len(spans)))
// could filter here
if ... | [
"func",
"(",
"connector",
"*",
"Forwarder",
")",
"AddSpans",
"(",
"ctx",
"context",
".",
"Context",
",",
"spans",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"error",
"{",
"atomic",
".",
"AddInt64",
"(",
"&",
"connector",
".",
"stats",
".",
"pipeline",
... | // AddSpans forwards traces to SignalFx, optionally through the sampler | [
"AddSpans",
"forwards",
"traces",
"to",
"SignalFx",
"optionally",
"through",
"the",
"sampler"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxforwarder.go#L187-L196 |
140,421 | signalfx/gateway | dp/dpbuffered/bufferedforwarder.go | AddDatapoints | func (forwarder *BufferedForwarder) AddDatapoints(ctx context.Context, points []*datapoint.Datapoint) error {
if forwarder.checker.CtxFlagCheck.HasFlag(ctx) {
forwarder.cdim.With(ctx, forwarder.logger).Log("Datapoint call recieved in buffered forwarder")
}
atomic.AddInt64(&forwarder.stats.totalDatapointsBuffered, ... | go | func (forwarder *BufferedForwarder) AddDatapoints(ctx context.Context, points []*datapoint.Datapoint) error {
if forwarder.checker.CtxFlagCheck.HasFlag(ctx) {
forwarder.cdim.With(ctx, forwarder.logger).Log("Datapoint call recieved in buffered forwarder")
}
atomic.AddInt64(&forwarder.stats.totalDatapointsBuffered, ... | [
"func",
"(",
"forwarder",
"*",
"BufferedForwarder",
")",
"AddDatapoints",
"(",
"ctx",
"context",
".",
"Context",
",",
"points",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"error",
"{",
"if",
"forwarder",
".",
"checker",
".",
"CtxFlagCheck",
".",
"H... | // AddDatapoints sends the datapoints to a chan buffer that eventually is flushed in big groups | [
"AddDatapoints",
"sends",
"the",
"datapoints",
"to",
"a",
"chan",
"buffer",
"that",
"eventually",
"is",
"flushed",
"in",
"big",
"groups"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpbuffered/bufferedforwarder.go#L97-L114 |
140,422 | signalfx/gateway | dp/dpbuffered/bufferedforwarder.go | AddEvents | func (forwarder *BufferedForwarder) AddEvents(ctx context.Context, events []*event.Event) error {
if forwarder.checker.CtxFlagCheck.HasFlag(ctx) {
forwarder.cdim.With(ctx, forwarder.logger).Log("Events call received in buffered forwarder")
}
atomic.AddInt64(&forwarder.stats.totalEventsBuffered, int64(len(events)))... | go | func (forwarder *BufferedForwarder) AddEvents(ctx context.Context, events []*event.Event) error {
if forwarder.checker.CtxFlagCheck.HasFlag(ctx) {
forwarder.cdim.With(ctx, forwarder.logger).Log("Events call received in buffered forwarder")
}
atomic.AddInt64(&forwarder.stats.totalEventsBuffered, int64(len(events)))... | [
"func",
"(",
"forwarder",
"*",
"BufferedForwarder",
")",
"AddEvents",
"(",
"ctx",
"context",
".",
"Context",
",",
"events",
"[",
"]",
"*",
"event",
".",
"Event",
")",
"error",
"{",
"if",
"forwarder",
".",
"checker",
".",
"CtxFlagCheck",
".",
"HasFlag",
"... | // AddEvents sends the events to a chan buffer that eventually is flushed in big groups | [
"AddEvents",
"sends",
"the",
"events",
"to",
"a",
"chan",
"buffer",
"that",
"eventually",
"is",
"flushed",
"in",
"big",
"groups"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpbuffered/bufferedforwarder.go#L123-L140 |
140,423 | signalfx/gateway | dp/dpbuffered/bufferedforwarder.go | AddSpans | func (forwarder *BufferedForwarder) AddSpans(ctx context.Context, traces []*trace.Span) error {
atomic.AddInt64(&forwarder.stats.totalTracesBuffered, int64(len(traces)))
if *forwarder.config.MaxTotalSpans <= atomic.LoadInt64(&forwarder.stats.totalTracesBuffered) {
atomic.AddInt64(&forwarder.stats.totalTracesBuffere... | go | func (forwarder *BufferedForwarder) AddSpans(ctx context.Context, traces []*trace.Span) error {
atomic.AddInt64(&forwarder.stats.totalTracesBuffered, int64(len(traces)))
if *forwarder.config.MaxTotalSpans <= atomic.LoadInt64(&forwarder.stats.totalTracesBuffered) {
atomic.AddInt64(&forwarder.stats.totalTracesBuffere... | [
"func",
"(",
"forwarder",
"*",
"BufferedForwarder",
")",
"AddSpans",
"(",
"ctx",
"context",
".",
"Context",
",",
"traces",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"error",
"{",
"atomic",
".",
"AddInt64",
"(",
"&",
"forwarder",
".",
"stats",
".",
"tot... | // AddSpans sends the traces to a chan buffer that traceually is flushed in big groups | [
"AddSpans",
"sends",
"the",
"traces",
"to",
"a",
"chan",
"buffer",
"that",
"traceually",
"is",
"flushed",
"in",
"big",
"groups"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpbuffered/bufferedforwarder.go#L149-L163 |
140,424 | signalfx/gateway | dp/dpbuffered/bufferedforwarder.go | Datapoints | func (forwarder *BufferedForwarder) Datapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{
sfxclient.Gauge("datapoint_chan_backup_size", nil, int64(len(forwarder.dpChan))),
sfxclient.Gauge("event_chan_backup_size", nil, int64(len(forwarder.eChan))),
sfxclient.Gauge("datapoint_backup_size", nil, ato... | go | func (forwarder *BufferedForwarder) Datapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{
sfxclient.Gauge("datapoint_chan_backup_size", nil, int64(len(forwarder.dpChan))),
sfxclient.Gauge("event_chan_backup_size", nil, int64(len(forwarder.eChan))),
sfxclient.Gauge("datapoint_backup_size", nil, ato... | [
"func",
"(",
"forwarder",
"*",
"BufferedForwarder",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"sfxclient",
".",
"Gauge",
"(",
"\"",
"\"",
",",
"nil",
","... | // Datapoints related to this forwarder, including errors processing datapoints | [
"Datapoints",
"related",
"to",
"this",
"forwarder",
"including",
"errors",
"processing",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpbuffered/bufferedforwarder.go#L166-L175 |
140,425 | signalfx/gateway | dp/dpbuffered/bufferedforwarder.go | Pipeline | func (forwarder *BufferedForwarder) Pipeline() int64 {
return int64(len(forwarder.dpChan)) + int64(len(forwarder.eChan)) + atomic.LoadInt64(&forwarder.stats.datapointsInFlight) + atomic.LoadInt64(&forwarder.stats.eventsInFlight) + int64(len(forwarder.tChan)) + atomic.LoadInt64(&forwarder.stats.tracesInFlight)
} | go | func (forwarder *BufferedForwarder) Pipeline() int64 {
return int64(len(forwarder.dpChan)) + int64(len(forwarder.eChan)) + atomic.LoadInt64(&forwarder.stats.datapointsInFlight) + atomic.LoadInt64(&forwarder.stats.eventsInFlight) + int64(len(forwarder.tChan)) + atomic.LoadInt64(&forwarder.stats.tracesInFlight)
} | [
"func",
"(",
"forwarder",
"*",
"BufferedForwarder",
")",
"Pipeline",
"(",
")",
"int64",
"{",
"return",
"int64",
"(",
"len",
"(",
"forwarder",
".",
"dpChan",
")",
")",
"+",
"int64",
"(",
"len",
"(",
"forwarder",
".",
"eChan",
")",
")",
"+",
"atomic",
... | // Pipeline for a BufferedForwarder is the total of all buffers and what is in flight | [
"Pipeline",
"for",
"a",
"BufferedForwarder",
"is",
"the",
"total",
"of",
"all",
"buffers",
"and",
"what",
"is",
"in",
"flight"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpbuffered/bufferedforwarder.go#L178-L180 |
140,426 | signalfx/gateway | dp/dpbuffered/bufferedforwarder.go | Close | func (forwarder *BufferedForwarder) Close() error {
forwarder.stopFunc()
forwarder.threadsWaitingToDie.Wait()
return forwarder.closeSender()
} | go | func (forwarder *BufferedForwarder) Close() error {
forwarder.stopFunc()
forwarder.threadsWaitingToDie.Wait()
return forwarder.closeSender()
} | [
"func",
"(",
"forwarder",
"*",
"BufferedForwarder",
")",
"Close",
"(",
")",
"error",
"{",
"forwarder",
".",
"stopFunc",
"(",
")",
"\n",
"forwarder",
".",
"threadsWaitingToDie",
".",
"Wait",
"(",
")",
"\n",
"return",
"forwarder",
".",
"closeSender",
"(",
")... | // Close stops the threads that are flushing channel points to the next forwarder | [
"Close",
"stops",
"the",
"threads",
"that",
"are",
"flushing",
"channel",
"points",
"to",
"the",
"next",
"forwarder"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpbuffered/bufferedforwarder.go#L261-L265 |
140,427 | signalfx/gateway | dp/dpbuffered/bufferedforwarder.go | NewBufferedForwarder | func NewBufferedForwarder(ctx context.Context, config *Config, sendTo signalfx.Sink, closeIt, afterStartup func() error, logger log.Logger, debugEnpoints func() map[string]http.Handler) *BufferedForwarder {
config = pointer.FillDefaultFrom(config, DefaultConfig).(*Config)
logCtx := log.NewContext(logger).With(logkey.... | go | func NewBufferedForwarder(ctx context.Context, config *Config, sendTo signalfx.Sink, closeIt, afterStartup func() error, logger log.Logger, debugEnpoints func() map[string]http.Handler) *BufferedForwarder {
config = pointer.FillDefaultFrom(config, DefaultConfig).(*Config)
logCtx := log.NewContext(logger).With(logkey.... | [
"func",
"NewBufferedForwarder",
"(",
"ctx",
"context",
".",
"Context",
",",
"config",
"*",
"Config",
",",
"sendTo",
"signalfx",
".",
"Sink",
",",
"closeIt",
",",
"afterStartup",
"func",
"(",
")",
"error",
",",
"logger",
"log",
".",
"Logger",
",",
"debugEnp... | // NewBufferedForwarder is used only by this package to create a forwarder that buffers its
// datapoint channel | [
"NewBufferedForwarder",
"is",
"used",
"only",
"by",
"this",
"package",
"to",
"create",
"a",
"forwarder",
"that",
"buffers",
"its",
"datapoint",
"channel"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpbuffered/bufferedforwarder.go#L365-L388 |
140,428 | signalfx/gateway | protocol/demultiplexer/demultiplexer.go | AddDatapoints | func (streamer *Demultiplexer) AddDatapoints(ctx context.Context, points []*datapoint.Datapoint) error {
if len(points) == 0 {
return nil
}
streamer.handleLateOrFuturePoints(points)
var errs []error
for _, sendTo := range streamer.DatapointSinks {
if err := sendTo.AddDatapoints(ctx, points); err != nil {
er... | go | func (streamer *Demultiplexer) AddDatapoints(ctx context.Context, points []*datapoint.Datapoint) error {
if len(points) == 0 {
return nil
}
streamer.handleLateOrFuturePoints(points)
var errs []error
for _, sendTo := range streamer.DatapointSinks {
if err := sendTo.AddDatapoints(ctx, points); err != nil {
er... | [
"func",
"(",
"streamer",
"*",
"Demultiplexer",
")",
"AddDatapoints",
"(",
"ctx",
"context",
".",
"Context",
",",
"points",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"error",
"{",
"if",
"len",
"(",
"points",
")",
"==",
"0",
"{",
"return",
"nil"... | // AddDatapoints forwards all points to each sendTo sink. Returns the error message of the last
// sink to have an error. | [
"AddDatapoints",
"forwards",
"all",
"points",
"to",
"each",
"sendTo",
"sink",
".",
"Returns",
"the",
"error",
"message",
"of",
"the",
"last",
"sink",
"to",
"have",
"an",
"error",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/demultiplexer/demultiplexer.go#L39-L51 |
140,429 | signalfx/gateway | protocol/demultiplexer/demultiplexer.go | AddEvents | func (streamer *Demultiplexer) AddEvents(ctx context.Context, events []*event.Event) error {
if len(events) == 0 {
return nil
}
streamer.handleLateOrFutureEvents(events)
var errs []error
for _, sendTo := range streamer.EventSinks {
if err := sendTo.AddEvents(ctx, events); err != nil {
errs = append(errs, er... | go | func (streamer *Demultiplexer) AddEvents(ctx context.Context, events []*event.Event) error {
if len(events) == 0 {
return nil
}
streamer.handleLateOrFutureEvents(events)
var errs []error
for _, sendTo := range streamer.EventSinks {
if err := sendTo.AddEvents(ctx, events); err != nil {
errs = append(errs, er... | [
"func",
"(",
"streamer",
"*",
"Demultiplexer",
")",
"AddEvents",
"(",
"ctx",
"context",
".",
"Context",
",",
"events",
"[",
"]",
"*",
"event",
".",
"Event",
")",
"error",
"{",
"if",
"len",
"(",
"events",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
... | // AddEvents forwards all events to each sendTo sink. Returns the error message of the last
// sink to have an error. | [
"AddEvents",
"forwards",
"all",
"events",
"to",
"each",
"sendTo",
"sink",
".",
"Returns",
"the",
"error",
"message",
"of",
"the",
"last",
"sink",
"to",
"have",
"an",
"error",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/demultiplexer/demultiplexer.go#L71-L83 |
140,430 | signalfx/gateway | protocol/demultiplexer/demultiplexer.go | AddSpans | func (streamer *Demultiplexer) AddSpans(ctx context.Context, spans []*trace.Span) error {
if len(spans) == 0 {
return nil
}
streamer.handleLateOrFutureSpans(spans)
var errs []error
for i, sendTo := range streamer.TraceSinks {
toSend := spans
if i < len(streamer.TraceSinks)-1 {
toSend = deepCopySpans(spans... | go | func (streamer *Demultiplexer) AddSpans(ctx context.Context, spans []*trace.Span) error {
if len(spans) == 0 {
return nil
}
streamer.handleLateOrFutureSpans(spans)
var errs []error
for i, sendTo := range streamer.TraceSinks {
toSend := spans
if i < len(streamer.TraceSinks)-1 {
toSend = deepCopySpans(spans... | [
"func",
"(",
"streamer",
"*",
"Demultiplexer",
")",
"AddSpans",
"(",
"ctx",
"context",
".",
"Context",
",",
"spans",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"error",
"{",
"if",
"len",
"(",
"spans",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",... | // AddSpans forwards all traces to each sentTo sink. Returns the error of the last sink to have an error.
// to avoid conflicts with adding tags in forwarders, each span needs to be a copy to avoid concurrent modification issues | [
"AddSpans",
"forwards",
"all",
"traces",
"to",
"each",
"sentTo",
"sink",
".",
"Returns",
"the",
"error",
"of",
"the",
"last",
"sink",
"to",
"have",
"an",
"error",
".",
"to",
"avoid",
"conflicts",
"with",
"adding",
"tags",
"in",
"forwarders",
"each",
"span"... | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/demultiplexer/demultiplexer.go#L103-L119 |
140,431 | signalfx/gateway | protocol/demultiplexer/demultiplexer.go | Datapoints | func (streamer *Demultiplexer) Datapoints() []*datapoint.Datapoint {
var dps []*datapoint.Datapoint
if streamer.FutureDuration != nil {
dps = append(dps, []*datapoint.Datapoint{
sfxclient.Cumulative("future.count", map[string]string{"type": "datapoint"}, atomic.LoadInt64(&streamer.stats.futureDps)),
sfxclient... | go | func (streamer *Demultiplexer) Datapoints() []*datapoint.Datapoint {
var dps []*datapoint.Datapoint
if streamer.FutureDuration != nil {
dps = append(dps, []*datapoint.Datapoint{
sfxclient.Cumulative("future.count", map[string]string{"type": "datapoint"}, atomic.LoadInt64(&streamer.stats.futureDps)),
sfxclient... | [
"func",
"(",
"streamer",
"*",
"Demultiplexer",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"var",
"dps",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"\n",
"if",
"streamer",
".",
"FutureDuration",
"!=",
"nil",
"{",
... | // Datapoints adheres to the sfxclient.Collector interface | [
"Datapoints",
"adheres",
"to",
"the",
"sfxclient",
".",
"Collector",
"interface"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/demultiplexer/demultiplexer.go#L167-L184 |
140,432 | signalfx/gateway | protocol/signalfx/trace_jaeger.go | NewJaegerThriftTraceDecoderV1 | func NewJaegerThriftTraceDecoderV1(logger log.Logger, sink trace.Sink) *JaegerThriftTraceDecoderV1 {
return &JaegerThriftTraceDecoderV1{
Logger: logger,
Sink: sink,
protocolFactory: thrift.NewTBinaryProtocolFactoryDefault(),
bufferPool: sync.Pool{
New: func() interface{} {
return byt... | go | func NewJaegerThriftTraceDecoderV1(logger log.Logger, sink trace.Sink) *JaegerThriftTraceDecoderV1 {
return &JaegerThriftTraceDecoderV1{
Logger: logger,
Sink: sink,
protocolFactory: thrift.NewTBinaryProtocolFactoryDefault(),
bufferPool: sync.Pool{
New: func() interface{} {
return byt... | [
"func",
"NewJaegerThriftTraceDecoderV1",
"(",
"logger",
"log",
".",
"Logger",
",",
"sink",
"trace",
".",
"Sink",
")",
"*",
"JaegerThriftTraceDecoderV1",
"{",
"return",
"&",
"JaegerThriftTraceDecoderV1",
"{",
"Logger",
":",
"logger",
",",
"Sink",
":",
"sink",
","... | // NewJaegerThriftTraceDecoderV1 creates a new decoder for Jaeger Thrift spans | [
"NewJaegerThriftTraceDecoderV1",
"creates",
"a",
"new",
"decoder",
"for",
"Jaeger",
"Thrift",
"spans"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/trace_jaeger.go#L35-L47 |
140,433 | signalfx/gateway | protocol/signalfx/trace_jaeger.go | materializeWithJSON | func materializeWithJSON(logFields []*jThrift.Tag) ([]byte, error) {
fields := make(map[string]string, len(logFields))
for i := range logFields {
fields[logFields[i].Key] = tagValueToString(logFields[i])
}
if event, ok := fields["event"]; ok && len(fields) == 1 {
return []byte(event), nil
}
return json.Marsha... | go | func materializeWithJSON(logFields []*jThrift.Tag) ([]byte, error) {
fields := make(map[string]string, len(logFields))
for i := range logFields {
fields[logFields[i].Key] = tagValueToString(logFields[i])
}
if event, ok := fields["event"]; ok && len(fields) == 1 {
return []byte(event), nil
}
return json.Marsha... | [
"func",
"materializeWithJSON",
"(",
"logFields",
"[",
"]",
"*",
"jThrift",
".",
"Tag",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"fields",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"len",
"(",
"logFields",
")",
")",
"\n... | // materializeWithJSON converts log Fields into JSON string, or just the field
// value of the event field, if present. | [
"materializeWithJSON",
"converts",
"log",
"Fields",
"into",
"JSON",
"string",
"or",
"just",
"the",
"field",
"value",
"of",
"the",
"event",
"field",
"if",
"present",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/trace_jaeger.go#L277-L286 |
140,434 | signalfx/gateway | protocol/signalfx/trace_jaeger.go | padID | func padID(id string) string {
expectedLen := 0
if len(id) < 16 {
expectedLen = 16
} else if len(id) > 16 && len(id) < 32 {
expectedLen = 32
} else {
return id
}
return pads[expectedLen-len(id)] + id
} | go | func padID(id string) string {
expectedLen := 0
if len(id) < 16 {
expectedLen = 16
} else if len(id) > 16 && len(id) < 32 {
expectedLen = 32
} else {
return id
}
return pads[expectedLen-len(id)] + id
} | [
"func",
"padID",
"(",
"id",
"string",
")",
"string",
"{",
"expectedLen",
":=",
"0",
"\n",
"if",
"len",
"(",
"id",
")",
"<",
"16",
"{",
"expectedLen",
"=",
"16",
"\n",
"}",
"else",
"if",
"len",
"(",
"id",
")",
">",
"16",
"&&",
"len",
"(",
"id",
... | // The way IDs get converted to strings in some of the jaeger code, leading 0s
// can be dropped, which will cause the ids to fail validation on our backend. | [
"The",
"way",
"IDs",
"get",
"converted",
"to",
"strings",
"in",
"some",
"of",
"the",
"jaeger",
"code",
"leading",
"0s",
"can",
"be",
"dropped",
"which",
"will",
"cause",
"the",
"ids",
"to",
"fail",
"validation",
"on",
"our",
"backend",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/trace_jaeger.go#L309-L320 |
140,435 | signalfx/gateway | protocol/protocol.go | AddEvents | func (u *UneventfulForwarder) AddEvents(ctx context.Context, events []*event.Event) error {
return nil
} | go | func (u *UneventfulForwarder) AddEvents(ctx context.Context, events []*event.Event) error {
return nil
} | [
"func",
"(",
"u",
"*",
"UneventfulForwarder",
")",
"AddEvents",
"(",
"ctx",
"context",
".",
"Context",
",",
"events",
"[",
"]",
"*",
"event",
".",
"Event",
")",
"error",
"{",
"return",
"nil",
"\n",
"}"
] | // AddEvents does nothing and returns nil | [
"AddEvents",
"does",
"nothing",
"and",
"returns",
"nil"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/protocol.go#L75-L77 |
140,436 | signalfx/gateway | protocol/protocol.go | AddSpans | func (u *UneventfulForwarder) AddSpans(ctx context.Context, events []*trace.Span) error {
return nil
} | go | func (u *UneventfulForwarder) AddSpans(ctx context.Context, events []*trace.Span) error {
return nil
} | [
"func",
"(",
"u",
"*",
"UneventfulForwarder",
")",
"AddSpans",
"(",
"ctx",
"context",
".",
"Context",
",",
"events",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"error",
"{",
"return",
"nil",
"\n",
"}"
] | // AddSpans does nothing and returns nil | [
"AddSpans",
"does",
"nothing",
"and",
"returns",
"nil"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/protocol.go#L80-L82 |
140,437 | signalfx/gateway | protocol/protocol.go | ListenerDims | func ListenerDims(name string, typ string) map[string]string {
return map[string]string{
"location": "listener",
"name": name,
"type": typ,
}
} | go | func ListenerDims(name string, typ string) map[string]string {
return map[string]string{
"location": "listener",
"name": name,
"type": typ,
}
} | [
"func",
"ListenerDims",
"(",
"name",
"string",
",",
"typ",
"string",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"return",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"name",
",",
"\"",
"\"",
":... | // ListenerDims are the common stat dimensions we expect on listener protocols | [
"ListenerDims",
"are",
"the",
"common",
"stat",
"dimensions",
"we",
"expect",
"on",
"listener",
"protocols"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/protocol.go#L90-L96 |
140,438 | signalfx/gateway | protocol/protocol.go | ForwarderDims | func ForwarderDims(name string, typ string) map[string]string {
return map[string]string{
"location": "forwarder",
"name": name,
"type": typ,
}
} | go | func ForwarderDims(name string, typ string) map[string]string {
return map[string]string{
"location": "forwarder",
"name": name,
"type": typ,
}
} | [
"func",
"ForwarderDims",
"(",
"name",
"string",
",",
"typ",
"string",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"return",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"name",
",",
"\"",
"\"",
"... | // ForwarderDims are the common stat dimensions we expect on forwarder protocols | [
"ForwarderDims",
"are",
"the",
"common",
"stat",
"dimensions",
"we",
"expect",
"on",
"forwarder",
"protocols"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/protocol.go#L99-L105 |
140,439 | signalfx/gateway | protocol/collectd/collectdlistener.go | Datapoints | func (s *ListenerServer) Datapoints() []*datapoint.Datapoint {
return append(s.collector.Datapoints(), s.HealthDatapoints()...)
} | go | func (s *ListenerServer) Datapoints() []*datapoint.Datapoint {
return append(s.collector.Datapoints(), s.HealthDatapoints()...)
} | [
"func",
"(",
"s",
"*",
"ListenerServer",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"append",
"(",
"s",
".",
"collector",
".",
"Datapoints",
"(",
")",
",",
"s",
".",
"HealthDatapoints",
"(",
")",
"...",
... | // Datapoints returns JSON decoder datapoints | [
"Datapoints",
"returns",
"JSON",
"decoder",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/collectd/collectdlistener.go#L46-L48 |
140,440 | signalfx/gateway | protocol/collectd/collectdlistener.go | NewListener | func NewListener(sink dpsink.Sink, passedConf *ListenerConfig) (*ListenerServer, error) {
zippers := zipper.NewZipper()
conf := pointer.FillDefaultFrom(passedConf, defaultListenerConfig).(*ListenerConfig)
listener, err := net.Listen("tcp", *conf.ListenAddr)
if err != nil {
return nil, err
}
r := mux.NewRouter... | go | func NewListener(sink dpsink.Sink, passedConf *ListenerConfig) (*ListenerServer, error) {
zippers := zipper.NewZipper()
conf := pointer.FillDefaultFrom(passedConf, defaultListenerConfig).(*ListenerConfig)
listener, err := net.Listen("tcp", *conf.ListenAddr)
if err != nil {
return nil, err
}
r := mux.NewRouter... | [
"func",
"NewListener",
"(",
"sink",
"dpsink",
".",
"Sink",
",",
"passedConf",
"*",
"ListenerConfig",
")",
"(",
"*",
"ListenerServer",
",",
"error",
")",
"{",
"zippers",
":=",
"zipper",
".",
"NewZipper",
"(",
")",
"\n",
"conf",
":=",
"pointer",
".",
"Fill... | // NewListener serves http collectd requests | [
"NewListener",
"serves",
"http",
"collectd",
"requests"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/collectd/collectdlistener.go#L165-L211 |
140,441 | signalfx/gateway | protocol/wavefront/wavefrontlistener.go | Datapoints | func (listener *Listener) Datapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{
sfxclient.Cumulative("invalid_datapoints", nil, atomic.LoadInt64(&listener.stats.invalidDatapoints)),
sfxclient.Cumulative("total_connections", nil, atomic.LoadInt64(&listener.stats.totalConnections)),
sfxclient.Gauge(... | go | func (listener *Listener) Datapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{
sfxclient.Cumulative("invalid_datapoints", nil, atomic.LoadInt64(&listener.stats.invalidDatapoints)),
sfxclient.Cumulative("total_connections", nil, atomic.LoadInt64(&listener.stats.totalConnections)),
sfxclient.Gauge(... | [
"func",
"(",
"listener",
"*",
"Listener",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"sfxclient",
".",
"Cumulative",
"(",
"\"",
"\"",
",",
"nil",
",",
"... | // Datapoints reports information about the total points seen by wavefront | [
"Datapoints",
"reports",
"information",
"about",
"the",
"total",
"points",
"seen",
"by",
"wavefront"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/wavefront/wavefrontlistener.go#L52-L60 |
140,442 | signalfx/gateway | flaghelpers/flaghelpers.go | IsSet | func (s *StringFlag) IsSet() bool {
if s != nil && s.string != nil {
return true
}
return false
} | go | func (s *StringFlag) IsSet() bool {
if s != nil && s.string != nil {
return true
}
return false
} | [
"func",
"(",
"s",
"*",
"StringFlag",
")",
"IsSet",
"(",
")",
"bool",
"{",
"if",
"s",
"!=",
"nil",
"&&",
"s",
".",
"string",
"!=",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsSet indicates if whether the flag has actually been set or not | [
"IsSet",
"indicates",
"if",
"whether",
"the",
"flag",
"has",
"actually",
"been",
"set",
"or",
"not"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/flaghelpers/flaghelpers.go#L15-L20 |
140,443 | signalfx/gateway | protocol/signalfx/spanobfuscation/spantagobfuscation.go | NewObf | func NewObf(ruleConfigs []*TagMatchRuleConfig, next obfsink) (*SpanTagObfuscation, error) {
rules, err := getRules(ruleConfigs)
if err != nil {
return nil, err
}
return &SpanTagObfuscation{
rules: rules,
next: next,
}, nil
} | go | func NewObf(ruleConfigs []*TagMatchRuleConfig, next obfsink) (*SpanTagObfuscation, error) {
rules, err := getRules(ruleConfigs)
if err != nil {
return nil, err
}
return &SpanTagObfuscation{
rules: rules,
next: next,
}, nil
} | [
"func",
"NewObf",
"(",
"ruleConfigs",
"[",
"]",
"*",
"TagMatchRuleConfig",
",",
"next",
"obfsink",
")",
"(",
"*",
"SpanTagObfuscation",
",",
"error",
")",
"{",
"rules",
",",
"err",
":=",
"getRules",
"(",
"ruleConfigs",
")",
"\n",
"if",
"err",
"!=",
"nil"... | // NewObf returns you a new SpanTagObfuscation object | [
"NewObf",
"returns",
"you",
"a",
"new",
"SpanTagObfuscation",
"object"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/spanobfuscation/spantagobfuscation.go#L66-L75 |
140,444 | signalfx/gateway | protocol/signalfx/signalfxlistener.go | Datapoints | func (streamer *ListenerServer) Datapoints() []*datapoint.Datapoint {
return append(streamer.internalCollectors.Datapoints(), streamer.HealthDatapoints()...)
} | go | func (streamer *ListenerServer) Datapoints() []*datapoint.Datapoint {
return append(streamer.internalCollectors.Datapoints(), streamer.HealthDatapoints()...)
} | [
"func",
"(",
"streamer",
"*",
"ListenerServer",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"append",
"(",
"streamer",
".",
"internalCollectors",
".",
"Datapoints",
"(",
")",
",",
"streamer",
".",
"HealthDatapoin... | // Datapoints returns the datapoints about various internal endpoints | [
"Datapoints",
"returns",
"the",
"datapoints",
"about",
"various",
"internal",
"endpoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxlistener.go#L53-L55 |
140,445 | signalfx/gateway | protocol/signalfx/signalfxlistener.go | Datapoints | func (e *ErrorTrackerHandler) Datapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{
sfxclient.Cumulative("total_errors", nil, atomic.LoadInt64(&e.TotalErrors)),
}
} | go | func (e *ErrorTrackerHandler) Datapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{
sfxclient.Cumulative("total_errors", nil, atomic.LoadInt64(&e.TotalErrors)),
}
} | [
"func",
"(",
"e",
"*",
"ErrorTrackerHandler",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"sfxclient",
".",
"Cumulative",
"(",
"\"",
"\"",
",",
"nil",
",",... | // Datapoints gets TotalErrors stats | [
"Datapoints",
"gets",
"TotalErrors",
"stats"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxlistener.go#L76-L80 |
140,446 | signalfx/gateway | protocol/signalfx/signalfxlistener.go | NewListener | func NewListener(sink Sink, conf *ListenerConfig) (*ListenerServer, error) {
conf = pointer.FillDefaultFrom(conf, defaultListenerConfig).(*ListenerConfig)
listener, err := net.Listen("tcp", *conf.ListenAddr)
if err != nil {
return nil, errors.Annotatef(err, "cannot open listening address %s", *conf.ListenAddr)
}... | go | func NewListener(sink Sink, conf *ListenerConfig) (*ListenerServer, error) {
conf = pointer.FillDefaultFrom(conf, defaultListenerConfig).(*ListenerConfig)
listener, err := net.Listen("tcp", *conf.ListenAddr)
if err != nil {
return nil, errors.Annotatef(err, "cannot open listening address %s", *conf.ListenAddr)
}... | [
"func",
"NewListener",
"(",
"sink",
"Sink",
",",
"conf",
"*",
"ListenerConfig",
")",
"(",
"*",
"ListenerServer",
",",
"error",
")",
"{",
"conf",
"=",
"pointer",
".",
"FillDefaultFrom",
"(",
"conf",
",",
"defaultListenerConfig",
")",
".",
"(",
"*",
"Listene... | // NewListener servers http requests for Signalfx datapoints | [
"NewListener",
"servers",
"http",
"requests",
"for",
"Signalfx",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxlistener.go#L182-L230 |
140,447 | signalfx/gateway | protocol/signalfx/signalfxlistener.go | SetupChain | func SetupChain(ctx context.Context, sink Sink, chainType string, getReader func(Sink) ErrorReader, httpChain web.NextConstructor, logger log.Logger, moreConstructors ...web.Constructor) (http.Handler, sfxclient.Collector) {
zippers := zipper.NewZipper()
counter := &dpsink.Counter{
Logger: logger,
Dropped... | go | func SetupChain(ctx context.Context, sink Sink, chainType string, getReader func(Sink) ErrorReader, httpChain web.NextConstructor, logger log.Logger, moreConstructors ...web.Constructor) (http.Handler, sfxclient.Collector) {
zippers := zipper.NewZipper()
counter := &dpsink.Counter{
Logger: logger,
Dropped... | [
"func",
"SetupChain",
"(",
"ctx",
"context",
".",
"Context",
",",
"sink",
"Sink",
",",
"chainType",
"string",
",",
"getReader",
"func",
"(",
"Sink",
")",
"ErrorReader",
",",
"httpChain",
"web",
".",
"NextConstructor",
",",
"logger",
"log",
".",
"Logger",
"... | // SetupChain wraps the reader returned by getReader in an http.Handler along
// with some middleware that calculates internal metrics about requests. | [
"SetupChain",
"wraps",
"the",
"reader",
"returned",
"by",
"getReader",
"in",
"an",
"http",
".",
"Handler",
"along",
"with",
"some",
"middleware",
"that",
"calculates",
"internal",
"metrics",
"about",
"requests",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfxlistener.go#L273-L305 |
140,448 | signalfx/gateway | protocol/signalfx/datapoint.go | Datapoints | func (decoder *JSONDecoderV2) Datapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{
sfxclient.Counter("dropped_points", map[string]string{"protocol": "sfx_json_v2", "reason": "unknown_metric_type"}, atomic.LoadInt64(&decoder.unknownMetricType)),
sfxclient.Counter("dropped_points", map[string]string{... | go | func (decoder *JSONDecoderV2) Datapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{
sfxclient.Counter("dropped_points", map[string]string{"protocol": "sfx_json_v2", "reason": "unknown_metric_type"}, atomic.LoadInt64(&decoder.unknownMetricType)),
sfxclient.Counter("dropped_points", map[string]string{... | [
"func",
"(",
"decoder",
"*",
"JSONDecoderV2",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"sfxclient",
".",
"Counter",
"(",
"\"",
"\"",
",",
"map",
"[",
... | // Datapoints returns datapoints for json decoder v2 | [
"Datapoints",
"returns",
"datapoints",
"for",
"json",
"decoder",
"v2"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/datapoint.go#L178-L183 |
140,449 | signalfx/gateway | protocol/signalfx/datapoint.go | SetupProtobufV1Paths | func SetupProtobufV1Paths(r *mux.Router, handler http.Handler) {
r.Path("/datapoint").Methods("POST").Headers("Content-Type", "application/x-protobuf").Handler(handler)
r.Path("/v1/datapoint").Methods("POST").Headers("Content-Type", "application/x-protobuf").Handler(handler)
} | go | func SetupProtobufV1Paths(r *mux.Router, handler http.Handler) {
r.Path("/datapoint").Methods("POST").Headers("Content-Type", "application/x-protobuf").Handler(handler)
r.Path("/v1/datapoint").Methods("POST").Headers("Content-Type", "application/x-protobuf").Handler(handler)
} | [
"func",
"SetupProtobufV1Paths",
"(",
"r",
"*",
"mux",
".",
"Router",
",",
"handler",
"http",
".",
"Handler",
")",
"{",
"r",
".",
"Path",
"(",
"\"",
"\"",
")",
".",
"Methods",
"(",
"\"",
"\"",
")",
".",
"Headers",
"(",
"\"",
"\"",
",",
"\"",
"\"",... | // SetupProtobufV1Paths routes to R paths that should handle V1 Protobuf datapoints | [
"SetupProtobufV1Paths",
"routes",
"to",
"R",
"paths",
"that",
"should",
"handle",
"V1",
"Protobuf",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/datapoint.go#L276-L279 |
140,450 | signalfx/gateway | protocol/signalfx/datapoint.go | SetupJSONV1Paths | func SetupJSONV1Paths(r *mux.Router, handler http.Handler) {
SetupJSONByPaths(r, handler, "/datapoint")
SetupJSONByPaths(r, handler, "/v1/datapoint")
} | go | func SetupJSONV1Paths(r *mux.Router, handler http.Handler) {
SetupJSONByPaths(r, handler, "/datapoint")
SetupJSONByPaths(r, handler, "/v1/datapoint")
} | [
"func",
"SetupJSONV1Paths",
"(",
"r",
"*",
"mux",
".",
"Router",
",",
"handler",
"http",
".",
"Handler",
")",
"{",
"SetupJSONByPaths",
"(",
"r",
",",
"handler",
",",
"\"",
"\"",
")",
"\n",
"SetupJSONByPaths",
"(",
"r",
",",
"handler",
",",
"\"",
"\"",
... | // SetupJSONV1Paths routes to R paths that should handle V1 JSON datapoints | [
"SetupJSONV1Paths",
"routes",
"to",
"R",
"paths",
"that",
"should",
"handle",
"V1",
"JSON",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/datapoint.go#L291-L294 |
140,451 | signalfx/gateway | protocol/signalfx/unified.go | NextWrap | func NextWrap(wrapping NextSink) MiddlewareConstructor {
return func(sendTo Sink) Sink {
x := &nextWrapped{
forwardTo: sendTo,
wrapping: wrapping,
}
return x
}
} | go | func NextWrap(wrapping NextSink) MiddlewareConstructor {
return func(sendTo Sink) Sink {
x := &nextWrapped{
forwardTo: sendTo,
wrapping: wrapping,
}
return x
}
} | [
"func",
"NextWrap",
"(",
"wrapping",
"NextSink",
")",
"MiddlewareConstructor",
"{",
"return",
"func",
"(",
"sendTo",
"Sink",
")",
"Sink",
"{",
"x",
":=",
"&",
"nextWrapped",
"{",
"forwardTo",
":",
"sendTo",
",",
"wrapping",
":",
"wrapping",
",",
"}",
"\n",... | // NextWrap wraps a NextSink to make it usable by MiddlewareConstructor | [
"NextWrap",
"wraps",
"a",
"NextSink",
"to",
"make",
"it",
"usable",
"by",
"MiddlewareConstructor"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/unified.go#L28-L36 |
140,452 | signalfx/gateway | protocol/signalfx/unified.go | FromChain | func FromChain(endSink Sink, sinks ...MiddlewareConstructor) Sink {
for i := len(sinks) - 1; i >= 0; i-- {
endSink = sinks[i](endSink)
}
return endSink
} | go | func FromChain(endSink Sink, sinks ...MiddlewareConstructor) Sink {
for i := len(sinks) - 1; i >= 0; i-- {
endSink = sinks[i](endSink)
}
return endSink
} | [
"func",
"FromChain",
"(",
"endSink",
"Sink",
",",
"sinks",
"...",
"MiddlewareConstructor",
")",
"Sink",
"{",
"for",
"i",
":=",
"len",
"(",
"sinks",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"endSink",
"=",
"sinks",
"[",
"i",
"]",
"... | // FromChain creates an endpoint Sink that sends calls between multiple middlewares for things like
// counting points in between. | [
"FromChain",
"creates",
"an",
"endpoint",
"Sink",
"that",
"sends",
"calls",
"between",
"multiple",
"middlewares",
"for",
"things",
"like",
"counting",
"points",
"in",
"between",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/unified.go#L40-L45 |
140,453 | signalfx/gateway | protocol/signalfx/unified.go | IncludingDimensions | func IncludingDimensions(dims map[string]string, sink Sink) Sink {
if len(dims) == 0 {
return sink
}
return NextWrap(&WithDimensions{
Dimensions: dims,
})(sink)
} | go | func IncludingDimensions(dims map[string]string, sink Sink) Sink {
if len(dims) == 0 {
return sink
}
return NextWrap(&WithDimensions{
Dimensions: dims,
})(sink)
} | [
"func",
"IncludingDimensions",
"(",
"dims",
"map",
"[",
"string",
"]",
"string",
",",
"sink",
"Sink",
")",
"Sink",
"{",
"if",
"len",
"(",
"dims",
")",
"==",
"0",
"{",
"return",
"sink",
"\n",
"}",
"\n",
"return",
"NextWrap",
"(",
"&",
"WithDimensions",
... | // IncludingDimensions returns a sink that wraps another sink adding dims to each datapoint and
// event | [
"IncludingDimensions",
"returns",
"a",
"sink",
"that",
"wraps",
"another",
"sink",
"adding",
"dims",
"to",
"each",
"datapoint",
"and",
"event"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/unified.go#L66-L73 |
140,454 | signalfx/gateway | protocol/carbon/metricdeconstructor/identitymetricdeconstructor.go | Parse | func (parser *IdentityMetricDeconstructor) Parse(originalMetric string) (string, datapoint.MetricType, map[string]string, error) {
return originalMetric, datapoint.Gauge, map[string]string{}, nil
} | go | func (parser *IdentityMetricDeconstructor) Parse(originalMetric string) (string, datapoint.MetricType, map[string]string, error) {
return originalMetric, datapoint.Gauge, map[string]string{}, nil
} | [
"func",
"(",
"parser",
"*",
"IdentityMetricDeconstructor",
")",
"Parse",
"(",
"originalMetric",
"string",
")",
"(",
"string",
",",
"datapoint",
".",
"MetricType",
",",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"return",
"originalMetric",
"... | // Parse returns the zero dimension gauge | [
"Parse",
"returns",
"the",
"zero",
"dimension",
"gauge"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/metricdeconstructor/identitymetricdeconstructor.go#L10-L12 |
140,455 | signalfx/gateway | protocol/csv/csvforwarder.go | AddDatapoints | func (f *Forwarder) AddDatapoints(ctx context.Context, points []*datapoint.Datapoint) error {
points = f.FilterDatapoints(points)
f.mu.Lock()
defer f.mu.Unlock()
atomic.AddInt64(&f.stats.totalDatapointsForwarded, int64(len(points)))
for _, dp := range points {
if _, err := f.writeString(f.file, dp.String()+"\n")... | go | func (f *Forwarder) AddDatapoints(ctx context.Context, points []*datapoint.Datapoint) error {
points = f.FilterDatapoints(points)
f.mu.Lock()
defer f.mu.Unlock()
atomic.AddInt64(&f.stats.totalDatapointsForwarded, int64(len(points)))
for _, dp := range points {
if _, err := f.writeString(f.file, dp.String()+"\n")... | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"AddDatapoints",
"(",
"ctx",
"context",
".",
"Context",
",",
"points",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"error",
"{",
"points",
"=",
"f",
".",
"FilterDatapoints",
"(",
"points",
")",
"\n",
"f",... | // AddDatapoints writes the points to a file | [
"AddDatapoints",
"writes",
"the",
"points",
"to",
"a",
"file"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/csv/csvforwarder.go#L67-L78 |
140,456 | signalfx/gateway | protocol/csv/csvforwarder.go | AddEvents | func (f *Forwarder) AddEvents(ctx context.Context, events []*event.Event) error {
f.mu.Lock()
defer f.mu.Unlock()
atomic.AddInt64(&f.stats.totalEventsForwarded, int64(len(events)))
for _, e := range events {
if _, err := f.writeString(f.file, e.String()+"\n"); err != nil {
return errors.Annotate(err, "cannot w... | go | func (f *Forwarder) AddEvents(ctx context.Context, events []*event.Event) error {
f.mu.Lock()
defer f.mu.Unlock()
atomic.AddInt64(&f.stats.totalEventsForwarded, int64(len(events)))
for _, e := range events {
if _, err := f.writeString(f.file, e.String()+"\n"); err != nil {
return errors.Annotate(err, "cannot w... | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"AddEvents",
"(",
"ctx",
"context",
".",
"Context",
",",
"events",
"[",
"]",
"*",
"event",
".",
"Event",
")",
"error",
"{",
"f",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"f",
".",
"mu",
".",
"Unl... | // AddEvents writes the events to a file | [
"AddEvents",
"writes",
"the",
"events",
"to",
"a",
"file"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/csv/csvforwarder.go#L81-L91 |
140,457 | signalfx/gateway | protocol/csv/csvforwarder.go | AddSpans | func (f *Forwarder) AddSpans(ctx context.Context, spans []*trace.Span) error {
f.mu.Lock()
defer f.mu.Unlock()
atomic.AddInt64(&f.stats.totalSpansForwarded, int64(len(spans)))
for _, s := range spans {
b, err := json.Marshal(s)
if err == nil {
_, err = f.writeString(f.file, string(b)+"\n")
}
if err != ni... | go | func (f *Forwarder) AddSpans(ctx context.Context, spans []*trace.Span) error {
f.mu.Lock()
defer f.mu.Unlock()
atomic.AddInt64(&f.stats.totalSpansForwarded, int64(len(spans)))
for _, s := range spans {
b, err := json.Marshal(s)
if err == nil {
_, err = f.writeString(f.file, string(b)+"\n")
}
if err != ni... | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"AddSpans",
"(",
"ctx",
"context",
".",
"Context",
",",
"spans",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"error",
"{",
"f",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"f",
".",
"mu",
".",
"Unlock... | // AddSpans writes the spans to a file | [
"AddSpans",
"writes",
"the",
"spans",
"to",
"a",
"file"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/csv/csvforwarder.go#L94-L108 |
140,458 | signalfx/gateway | protocol/csv/csvforwarder.go | Close | func (f *Forwarder) Close() error {
f.mu.Lock()
defer f.mu.Unlock()
return f.file.Close()
} | go | func (f *Forwarder) Close() error {
f.mu.Lock()
defer f.mu.Unlock()
return f.file.Close()
} | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"Close",
"(",
")",
"error",
"{",
"f",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"f",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"f",
".",
"file",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Close the file we write to | [
"Close",
"the",
"file",
"we",
"write",
"to"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/csv/csvforwarder.go#L116-L120 |
140,459 | signalfx/gateway | protocol/carbon/carbonforwarder.go | NewForwarder | func NewForwarder(host string, passedConf *ForwarderConfig) (*Forwarder, error) {
conf := pointer.FillDefaultFrom(passedConf, defaultForwarderConfig).(*ForwarderConfig)
connectionAddress := net.JoinHostPort(host, strconv.FormatUint(uint64(*conf.Port), 10))
var d net.Dialer
d.Deadline = time.Now().Add(*conf.Timeou... | go | func NewForwarder(host string, passedConf *ForwarderConfig) (*Forwarder, error) {
conf := pointer.FillDefaultFrom(passedConf, defaultForwarderConfig).(*ForwarderConfig)
connectionAddress := net.JoinHostPort(host, strconv.FormatUint(uint64(*conf.Port), 10))
var d net.Dialer
d.Deadline = time.Now().Add(*conf.Timeou... | [
"func",
"NewForwarder",
"(",
"host",
"string",
",",
"passedConf",
"*",
"ForwarderConfig",
")",
"(",
"*",
"Forwarder",
",",
"error",
")",
"{",
"conf",
":=",
"pointer",
".",
"FillDefaultFrom",
"(",
"passedConf",
",",
"defaultForwarderConfig",
")",
".",
"(",
"*... | // NewForwarder creates a new unbuffered forwarder for sending points to carbon | [
"NewForwarder",
"creates",
"a",
"new",
"unbuffered",
"forwarder",
"for",
"sending",
"points",
"to",
"carbon"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/carbonforwarder.go#L51-L79 |
140,460 | signalfx/gateway | protocol/carbon/carbonforwarder.go | Datapoints | func (f *Forwarder) Datapoints() []*datapoint.Datapoint {
datapoints := f.pool.Datapoints()
datapoints = append(datapoints, f.GetFilteredDatapoints()...)
return datapoints
} | go | func (f *Forwarder) Datapoints() []*datapoint.Datapoint {
datapoints := f.pool.Datapoints()
datapoints = append(datapoints, f.GetFilteredDatapoints()...)
return datapoints
} | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"datapoints",
":=",
"f",
".",
"pool",
".",
"Datapoints",
"(",
")",
"\n",
"datapoints",
"=",
"append",
"(",
"datapoints",
",",
"f",
"."... | // Datapoints returns connection pool datapoints | [
"Datapoints",
"returns",
"connection",
"pool",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/carbonforwarder.go#L87-L91 |
140,461 | signalfx/gateway | protocol/carbon/carbonforwarder.go | AddDatapoints | func (f *Forwarder) AddDatapoints(ctx context.Context, points []*datapoint.Datapoint) (err error) {
openConnection := f.pool.Get()
if openConnection == nil {
openConnection, err = f.dialer("tcp", f.connectionAddress, f.connectionTimeout)
if err != nil {
err = errors.Annotatef(err, "cannot dial %s", f.connectio... | go | func (f *Forwarder) AddDatapoints(ctx context.Context, points []*datapoint.Datapoint) (err error) {
openConnection := f.pool.Get()
if openConnection == nil {
openConnection, err = f.dialer("tcp", f.connectionAddress, f.connectionTimeout)
if err != nil {
err = errors.Annotatef(err, "cannot dial %s", f.connectio... | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"AddDatapoints",
"(",
"ctx",
"context",
".",
"Context",
",",
"points",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"(",
"err",
"error",
")",
"{",
"openConnection",
":=",
"f",
".",
"pool",
".",
"Get",
"(... | // AddDatapoints sends the points to a carbon endpoint. Tries to reuse open connections | [
"AddDatapoints",
"sends",
"the",
"points",
"to",
"a",
"carbon",
"endpoint",
".",
"Tries",
"to",
"reuse",
"open",
"connections"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/carbonforwarder.go#L133-L176 |
140,462 | signalfx/gateway | protocol/signalfx/spanobfuscation/spantagremoval.go | AddSpans | func (o *SpanTagRemoval) AddSpans(ctx context.Context, spans []*trace.Span) error {
for _, s := range spans {
service := ""
name := ""
if s.LocalEndpoint != nil && s.LocalEndpoint.ServiceName != nil {
service = *s.LocalEndpoint.ServiceName
}
if s.Name != nil {
name = *s.Name
}
for _, r := range o.... | go | func (o *SpanTagRemoval) AddSpans(ctx context.Context, spans []*trace.Span) error {
for _, s := range spans {
service := ""
name := ""
if s.LocalEndpoint != nil && s.LocalEndpoint.ServiceName != nil {
service = *s.LocalEndpoint.ServiceName
}
if s.Name != nil {
name = *s.Name
}
for _, r := range o.... | [
"func",
"(",
"o",
"*",
"SpanTagRemoval",
")",
"AddSpans",
"(",
"ctx",
"context",
".",
"Context",
",",
"spans",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"error",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"spans",
"{",
"service",
":=",
"\"",
"\"",
... | // AddSpans maps all rules to all spans and deletes the specified tags if the service and operation match.
// This can be very expensive, and modifies the spans | [
"AddSpans",
"maps",
"all",
"rules",
"to",
"all",
"spans",
"and",
"deletes",
"the",
"specified",
"tags",
"if",
"the",
"service",
"and",
"operation",
"match",
".",
"This",
"can",
"be",
"very",
"expensive",
"and",
"modifies",
"the",
"spans"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/spanobfuscation/spantagremoval.go#L38-L58 |
140,463 | signalfx/gateway | protocol/signalfx/spanobfuscation/spantagremoval.go | NewRm | func NewRm(ruleConfigs []*TagMatchRuleConfig, next rmsink) (*SpanTagRemoval, error) {
rules, err := getRules(ruleConfigs)
if err != nil {
return nil, err
}
return &SpanTagRemoval{
rules: rules,
next: next,
}, nil
} | go | func NewRm(ruleConfigs []*TagMatchRuleConfig, next rmsink) (*SpanTagRemoval, error) {
rules, err := getRules(ruleConfigs)
if err != nil {
return nil, err
}
return &SpanTagRemoval{
rules: rules,
next: next,
}, nil
} | [
"func",
"NewRm",
"(",
"ruleConfigs",
"[",
"]",
"*",
"TagMatchRuleConfig",
",",
"next",
"rmsink",
")",
"(",
"*",
"SpanTagRemoval",
",",
"error",
")",
"{",
"rules",
",",
"err",
":=",
"getRules",
"(",
"ruleConfigs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{... | // NewRm returns you a new SpanTagRemoval object | [
"NewRm",
"returns",
"you",
"a",
"new",
"SpanTagRemoval",
"object"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/spanobfuscation/spantagremoval.go#L61-L71 |
140,464 | signalfx/gateway | protocol/signalfx/signalfx.go | NewDatumValue | func NewDatumValue(val *com_signalfx_metrics_protobuf.Datum) datapoint.Value {
if val.DoubleValue != nil {
return datapoint.NewFloatValue(val.GetDoubleValue())
}
if val.IntValue != nil {
return datapoint.NewIntValue(val.GetIntValue())
}
return datapoint.NewStringValue(val.GetStrValue())
} | go | func NewDatumValue(val *com_signalfx_metrics_protobuf.Datum) datapoint.Value {
if val.DoubleValue != nil {
return datapoint.NewFloatValue(val.GetDoubleValue())
}
if val.IntValue != nil {
return datapoint.NewIntValue(val.GetIntValue())
}
return datapoint.NewStringValue(val.GetStrValue())
} | [
"func",
"NewDatumValue",
"(",
"val",
"*",
"com_signalfx_metrics_protobuf",
".",
"Datum",
")",
"datapoint",
".",
"Value",
"{",
"if",
"val",
".",
"DoubleValue",
"!=",
"nil",
"{",
"return",
"datapoint",
".",
"NewFloatValue",
"(",
"val",
".",
"GetDoubleValue",
"("... | // NewDatumValue creates new datapoint value referenced from a value of the datum protobuf | [
"NewDatumValue",
"creates",
"new",
"datapoint",
"value",
"referenced",
"from",
"a",
"value",
"of",
"the",
"datum",
"protobuf"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfx.go#L20-L28 |
140,465 | signalfx/gateway | protocol/signalfx/signalfx.go | ValueToValue | func ValueToValue(v ValueToSend) (datapoint.Value, error) {
f, ok := v.(float64)
if ok {
if f == float64(int64(f)) {
return datapoint.NewIntValue(int64(f)), nil
}
return datapoint.NewFloatValue(f), nil
}
i, ok := v.(int64)
if ok {
return datapoint.NewIntValue(i), nil
}
i2, ok := v.(int)
if ok {
ret... | go | func ValueToValue(v ValueToSend) (datapoint.Value, error) {
f, ok := v.(float64)
if ok {
if f == float64(int64(f)) {
return datapoint.NewIntValue(int64(f)), nil
}
return datapoint.NewFloatValue(f), nil
}
i, ok := v.(int64)
if ok {
return datapoint.NewIntValue(i), nil
}
i2, ok := v.(int)
if ok {
ret... | [
"func",
"ValueToValue",
"(",
"v",
"ValueToSend",
")",
"(",
"datapoint",
".",
"Value",
",",
"error",
")",
"{",
"f",
",",
"ok",
":=",
"v",
".",
"(",
"float64",
")",
"\n",
"if",
"ok",
"{",
"if",
"f",
"==",
"float64",
"(",
"int64",
"(",
"f",
")",
"... | // ValueToValue converts the v2 JSON value to a core api Value | [
"ValueToValue",
"converts",
"the",
"v2",
"JSON",
"value",
"to",
"a",
"core",
"api",
"Value"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfx.go#L31-L52 |
140,466 | signalfx/gateway | protocol/signalfx/signalfx.go | PropertyAsRawType | func PropertyAsRawType(p *com_signalfx_metrics_protobuf.PropertyValue) interface{} {
if p == nil {
return nil
}
if p.BoolValue != nil {
return *p.BoolValue
}
if p.DoubleValue != nil {
return *p.DoubleValue
}
if p.StrValue != nil {
return *p.StrValue
}
if p.IntValue != nil {
return *p.IntValue
}
ret... | go | func PropertyAsRawType(p *com_signalfx_metrics_protobuf.PropertyValue) interface{} {
if p == nil {
return nil
}
if p.BoolValue != nil {
return *p.BoolValue
}
if p.DoubleValue != nil {
return *p.DoubleValue
}
if p.StrValue != nil {
return *p.StrValue
}
if p.IntValue != nil {
return *p.IntValue
}
ret... | [
"func",
"PropertyAsRawType",
"(",
"p",
"*",
"com_signalfx_metrics_protobuf",
".",
"PropertyValue",
")",
"interface",
"{",
"}",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"p",
".",
"BoolValue",
"!=",
"nil",
"{",
"return",
"*... | // PropertyAsRawType converts a protobuf property to a native Go type | [
"PropertyAsRawType",
"converts",
"a",
"protobuf",
"property",
"to",
"a",
"native",
"Go",
"type"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfx.go#L118-L135 |
140,467 | signalfx/gateway | protocol/signalfx/signalfx.go | NewProtobufEvent | func NewProtobufEvent(e *com_signalfx_metrics_protobuf.Event) (*event.Event, error) {
dims := make(map[string]string, len(e.GetDimensions())+1)
edims := e.GetDimensions()
for _, dpdim := range edims {
dims[dpdim.GetKey()] = dpdim.GetValue()
}
// sure wish protobuf has something eqiv of interface{} instead of on... | go | func NewProtobufEvent(e *com_signalfx_metrics_protobuf.Event) (*event.Event, error) {
dims := make(map[string]string, len(e.GetDimensions())+1)
edims := e.GetDimensions()
for _, dpdim := range edims {
dims[dpdim.GetKey()] = dpdim.GetValue()
}
// sure wish protobuf has something eqiv of interface{} instead of on... | [
"func",
"NewProtobufEvent",
"(",
"e",
"*",
"com_signalfx_metrics_protobuf",
".",
"Event",
")",
"(",
"*",
"event",
".",
"Event",
",",
"error",
")",
"{",
"dims",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"len",
"(",
"e",
".",
"GetDimen... | // NewProtobufEvent creates a new event from SignalFx's protobuf definition | [
"NewProtobufEvent",
"creates",
"a",
"new",
"event",
"from",
"SignalFx",
"s",
"protobuf",
"definition"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/signalfx.go#L140-L168 |
140,468 | signalfx/gateway | protocol/carbon/metricdeconstructor/configurabledelimiterdeconstructor.go | match | func (s *idMatcher) match(term string) bool {
if s.Term == term {
return true
}
return false
} | go | func (s *idMatcher) match(term string) bool {
if s.Term == term {
return true
}
return false
} | [
"func",
"(",
"s",
"*",
"idMatcher",
")",
"match",
"(",
"term",
"string",
")",
"bool",
"{",
"if",
"s",
".",
"Term",
"==",
"term",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // idMatcher matches iff the term is exactly equal to s.Term | [
"idMatcher",
"matches",
"iff",
"the",
"term",
"is",
"exactly",
"equal",
"to",
"s",
".",
"Term"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/metricdeconstructor/configurabledelimiterdeconstructor.go#L92-L97 |
140,469 | signalfx/gateway | protocol/carbon/metricdeconstructor/configurabledelimiterdeconstructor.go | match | func (t *termMatcher) match(term string) bool {
for _, o := range t.TermOptions {
if o.match(term) {
return true
}
}
return false
} | go | func (t *termMatcher) match(term string) bool {
for _, o := range t.TermOptions {
if o.match(term) {
return true
}
}
return false
} | [
"func",
"(",
"t",
"*",
"termMatcher",
")",
"match",
"(",
"term",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"o",
":=",
"range",
"t",
".",
"TermOptions",
"{",
"if",
"o",
".",
"match",
"(",
"term",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"... | // termMatcher matches if one of the terms within it matches | [
"termMatcher",
"matches",
"if",
"one",
"of",
"the",
"terms",
"within",
"it",
"matches"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/metricdeconstructor/configurabledelimiterdeconstructor.go#L116-L123 |
140,470 | signalfx/gateway | protocol/signalfx/format/signalfx_format.go | ToV2 | func (a *InputAnnotation) ToV2() *trace.Annotation {
return &trace.Annotation{
Timestamp: GetPointerToInt64(a.Timestamp),
Value: a.Value,
}
} | go | func (a *InputAnnotation) ToV2() *trace.Annotation {
return &trace.Annotation{
Timestamp: GetPointerToInt64(a.Timestamp),
Value: a.Value,
}
} | [
"func",
"(",
"a",
"*",
"InputAnnotation",
")",
"ToV2",
"(",
")",
"*",
"trace",
".",
"Annotation",
"{",
"return",
"&",
"trace",
".",
"Annotation",
"{",
"Timestamp",
":",
"GetPointerToInt64",
"(",
"a",
".",
"Timestamp",
")",
",",
"Value",
":",
"a",
".",
... | // ToV2 converts an InputAnnotation to a V2 InputAnnotation, which basically
// means dropping the endpoint. The endpoint must be considered in other
// logic to know which span to associate the endpoint with. | [
"ToV2",
"converts",
"an",
"InputAnnotation",
"to",
"a",
"V2",
"InputAnnotation",
"which",
"basically",
"means",
"dropping",
"the",
"endpoint",
".",
"The",
"endpoint",
"must",
"be",
"considered",
"in",
"other",
"logic",
"to",
"know",
"which",
"span",
"to",
"ass... | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/format/signalfx_format.go#L64-L69 |
140,471 | signalfx/gateway | protocol/signalfx/format/signalfx_format.go | GetPointerToInt64 | func GetPointerToInt64(p *float64) *int64 {
if p == nil {
return nil
}
i := int64(*p)
return &i
} | go | func GetPointerToInt64(p *float64) *int64 {
if p == nil {
return nil
}
i := int64(*p)
return &i
} | [
"func",
"GetPointerToInt64",
"(",
"p",
"*",
"float64",
")",
"*",
"int64",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"i",
":=",
"int64",
"(",
"*",
"p",
")",
"\n",
"return",
"&",
"i",
"\n",
"}"
] | // GetpointerToInt64 does that | [
"GetpointerToInt64",
"does",
"that"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/format/signalfx_format.go#L72-L78 |
140,472 | signalfx/gateway | protocol/carbon/metricdeconstructor/nildeconstructor.go | Parse | func (m *nilDeconstructor) Parse(originalMetric string) (string, datapoint.MetricType, map[string]string, error) {
return "", datapoint.Gauge, nil, errors.New("nilDeconstructor always returns an error")
} | go | func (m *nilDeconstructor) Parse(originalMetric string) (string, datapoint.MetricType, map[string]string, error) {
return "", datapoint.Gauge, nil, errors.New("nilDeconstructor always returns an error")
} | [
"func",
"(",
"m",
"*",
"nilDeconstructor",
")",
"Parse",
"(",
"originalMetric",
"string",
")",
"(",
"string",
",",
"datapoint",
".",
"MetricType",
",",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"return",
"\"",
"\"",
",",
"datapoint",
... | // Parse always returns an error | [
"Parse",
"always",
"returns",
"an",
"error"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/metricdeconstructor/nildeconstructor.go#L12-L14 |
140,473 | signalfx/gateway | protocol/carbon/carbonlistener.go | Close | func (listener *Listener) Close() error {
var err error
if listener.psocket != nil {
err = listener.psocket.Close()
}
if listener.udpsocket != nil {
err = listener.udpsocket.Close()
}
listener.wg.Wait()
return err
} | go | func (listener *Listener) Close() error {
var err error
if listener.psocket != nil {
err = listener.psocket.Close()
}
if listener.udpsocket != nil {
err = listener.udpsocket.Close()
}
listener.wg.Wait()
return err
} | [
"func",
"(",
"listener",
"*",
"Listener",
")",
"Close",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"listener",
".",
"psocket",
"!=",
"nil",
"{",
"err",
"=",
"listener",
".",
"psocket",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"if",
... | // Close the exposed carbon port | [
"Close",
"the",
"exposed",
"carbon",
"port"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/carbonlistener.go#L66-L77 |
140,474 | signalfx/gateway | protocol/carbon/carbonlistener.go | Addr | func (listener *Listener) Addr() net.Addr {
if listener.psocket != nil {
return listener.psocket.Addr()
}
return listener.udpsocket.LocalAddr()
} | go | func (listener *Listener) Addr() net.Addr {
if listener.psocket != nil {
return listener.psocket.Addr()
}
return listener.udpsocket.LocalAddr()
} | [
"func",
"(",
"listener",
"*",
"Listener",
")",
"Addr",
"(",
")",
"net",
".",
"Addr",
"{",
"if",
"listener",
".",
"psocket",
"!=",
"nil",
"{",
"return",
"listener",
".",
"psocket",
".",
"Addr",
"(",
")",
"\n",
"}",
"\n",
"return",
"listener",
".",
"... | // Addr returns the listening address of this carbon listener | [
"Addr",
"returns",
"the",
"listening",
"address",
"of",
"this",
"carbon",
"listener"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/carbonlistener.go#L228-L233 |
140,475 | signalfx/gateway | protocol/carbon/carbonlistener.go | NewListener | func NewListener(sendTo dpsink.Sink, passedConf *ListenerConfig) (*Listener, error) {
conf := pointer.FillDefaultFrom(passedConf, defaultListenerConfig).(*ListenerConfig)
receiver := Listener{
sink: sendTo,
metricDeconstructor: conf.MetricDeconstructor,
serverAcceptDeadline: *conf.ServerAcceptD... | go | func NewListener(sendTo dpsink.Sink, passedConf *ListenerConfig) (*Listener, error) {
conf := pointer.FillDefaultFrom(passedConf, defaultListenerConfig).(*ListenerConfig)
receiver := Listener{
sink: sendTo,
metricDeconstructor: conf.MetricDeconstructor,
serverAcceptDeadline: *conf.ServerAcceptD... | [
"func",
"NewListener",
"(",
"sendTo",
"dpsink",
".",
"Sink",
",",
"passedConf",
"*",
"ListenerConfig",
")",
"(",
"*",
"Listener",
",",
"error",
")",
"{",
"conf",
":=",
"pointer",
".",
"FillDefaultFrom",
"(",
"passedConf",
",",
"defaultListenerConfig",
")",
"... | // NewListener creates a new listener for carbon datapoints | [
"NewListener",
"creates",
"a",
"new",
"listener",
"for",
"carbon",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/carbon/carbonlistener.go#L262-L278 |
140,476 | signalfx/gateway | dp/dpdimsort/sort.go | NewOrdering | func NewOrdering(dimensionsOrder []string) Ordering {
dimensionOrderMap := make(map[string]int)
for index, strVal := range dimensionsOrder {
dimensionOrderMap[strVal] = index
}
return &orderedOrdering{
dimensionOrderMap: dimensionOrderMap,
}
} | go | func NewOrdering(dimensionsOrder []string) Ordering {
dimensionOrderMap := make(map[string]int)
for index, strVal := range dimensionsOrder {
dimensionOrderMap[strVal] = index
}
return &orderedOrdering{
dimensionOrderMap: dimensionOrderMap,
}
} | [
"func",
"NewOrdering",
"(",
"dimensionsOrder",
"[",
"]",
"string",
")",
"Ordering",
"{",
"dimensionOrderMap",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
")",
"\n",
"for",
"index",
",",
"strVal",
":=",
"range",
"dimensionsOrder",
"{",
"dimensionOrde... | // NewOrdering creates a sorter that sorts dimensions in dimensionsOrder order, putting
// any dimension inside dimensionsOrder ahead of any dimension not inside dimensionsOrder | [
"NewOrdering",
"creates",
"a",
"sorter",
"that",
"sorts",
"dimensions",
"in",
"dimensionsOrder",
"order",
"putting",
"any",
"dimension",
"inside",
"dimensionsOrder",
"ahead",
"of",
"any",
"dimension",
"not",
"inside",
"dimensionsOrder"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpdimsort/sort.go#L35-L43 |
140,477 | signalfx/gateway | dp/dpdimsort/sort.go | Sort | func (comp *orderedOrdering) Sort(dimensions map[string]string) []string {
dims := make([]string, 0, len(dimensions))
for k := range dimensions {
dims = append(dims, k)
}
req := &orderedDimensionSortRequest{
comparor: comp,
dimensions: dimensions,
currentOrder: dims,
}
sort.Sort(req)
return req.cur... | go | func (comp *orderedOrdering) Sort(dimensions map[string]string) []string {
dims := make([]string, 0, len(dimensions))
for k := range dimensions {
dims = append(dims, k)
}
req := &orderedDimensionSortRequest{
comparor: comp,
dimensions: dimensions,
currentOrder: dims,
}
sort.Sort(req)
return req.cur... | [
"func",
"(",
"comp",
"*",
"orderedOrdering",
")",
"Sort",
"(",
"dimensions",
"map",
"[",
"string",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"dims",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"dimensions",
")",
")",
"\n",
... | // SortDimensions uses a Ordering to return the sorted order of a dimension map. Useful for
// products that don't support dimension maps and require dimensions in a specific order | [
"SortDimensions",
"uses",
"a",
"Ordering",
"to",
"return",
"the",
"sorted",
"order",
"of",
"a",
"dimension",
"map",
".",
"Useful",
"for",
"products",
"that",
"don",
"t",
"support",
"dimension",
"maps",
"and",
"require",
"dimensions",
"in",
"a",
"specific",
"... | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/dp/dpdimsort/sort.go#L47-L59 |
140,478 | signalfx/gateway | protocol/prometheus/prometheuslistener.go | Datapoints | func (s *Server) Datapoints() []*datapoint.Datapoint {
return append(s.collector.Datapoints(), s.HealthDatapoints()...)
} | go | func (s *Server) Datapoints() []*datapoint.Datapoint {
return append(s.collector.Datapoints(), s.HealthDatapoints()...)
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Datapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"append",
"(",
"s",
".",
"collector",
".",
"Datapoints",
"(",
")",
",",
"s",
".",
"HealthDatapoints",
"(",
")",
"...",
")",
"... | // Datapoints returns decoder datapoints | [
"Datapoints",
"returns",
"decoder",
"datapoints"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/prometheus/prometheuslistener.go#L42-L44 |
140,479 | signalfx/gateway | protocol/prometheus/prometheuslistener.go | NewListener | func NewListener(sink dpsink.Sink, passedConf *Config) (*Server, error) {
conf := pointer.FillDefaultFrom(passedConf, defaultConfig).(*Config)
listener, err := net.Listen("tcp", *conf.ListenAddr)
if err != nil {
return nil, err
}
r := mux.NewRouter()
metricTracking := &web.RequestCounter{}
fullHandler := web... | go | func NewListener(sink dpsink.Sink, passedConf *Config) (*Server, error) {
conf := pointer.FillDefaultFrom(passedConf, defaultConfig).(*Config)
listener, err := net.Listen("tcp", *conf.ListenAddr)
if err != nil {
return nil, err
}
r := mux.NewRouter()
metricTracking := &web.RequestCounter{}
fullHandler := web... | [
"func",
"NewListener",
"(",
"sink",
"dpsink",
".",
"Sink",
",",
"passedConf",
"*",
"Config",
")",
"(",
"*",
"Server",
",",
"error",
")",
"{",
"conf",
":=",
"pointer",
".",
"FillDefaultFrom",
"(",
"passedConf",
",",
"defaultConfig",
")",
".",
"(",
"*",
... | // NewListener serves http prometheus requests | [
"NewListener",
"serves",
"http",
"prometheus",
"requests"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/prometheus/prometheuslistener.go#L207-L256 |
140,480 | signalfx/gateway | protocol/prometheus/prometheuslistener.go | SetupPrometheusPaths | func SetupPrometheusPaths(r *mux.Router, handler http.Handler, endpoint string) {
r.Path(endpoint).Methods("POST").Headers("Content-Type", "application/x-protobuf").Handler(handler)
} | go | func SetupPrometheusPaths(r *mux.Router, handler http.Handler, endpoint string) {
r.Path(endpoint).Methods("POST").Headers("Content-Type", "application/x-protobuf").Handler(handler)
} | [
"func",
"SetupPrometheusPaths",
"(",
"r",
"*",
"mux",
".",
"Router",
",",
"handler",
"http",
".",
"Handler",
",",
"endpoint",
"string",
")",
"{",
"r",
".",
"Path",
"(",
"endpoint",
")",
".",
"Methods",
"(",
"\"",
"\"",
")",
".",
"Headers",
"(",
"\"",... | // SetupPrometheusPaths tells the router which paths the given handler should handle | [
"SetupPrometheusPaths",
"tells",
"the",
"router",
"which",
"paths",
"the",
"given",
"handler",
"should",
"handle"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/prometheus/prometheuslistener.go#L259-L261 |
140,481 | signalfx/gateway | config/loader.go | NewLoader | func NewLoader(ctx context.Context, logger log.Logger, version string, debugContext *web.HeaderCtxFlag, itemFlagger *dpsink.ItemFlagger, ctxdims *log.CtxDimensions, next web.NextConstructor) *Loader {
sfxL := &signalFxLoader{
logger: logger,
rootContext: ctx,
versionString: version,
itemFlagger: ite... | go | func NewLoader(ctx context.Context, logger log.Logger, version string, debugContext *web.HeaderCtxFlag, itemFlagger *dpsink.ItemFlagger, ctxdims *log.CtxDimensions, next web.NextConstructor) *Loader {
sfxL := &signalFxLoader{
logger: logger,
rootContext: ctx,
versionString: version,
itemFlagger: ite... | [
"func",
"NewLoader",
"(",
"ctx",
"context",
".",
"Context",
",",
"logger",
"log",
".",
"Logger",
",",
"version",
"string",
",",
"debugContext",
"*",
"web",
".",
"HeaderCtxFlag",
",",
"itemFlagger",
"*",
"dpsink",
".",
"ItemFlagger",
",",
"ctxdims",
"*",
"l... | // NewLoader creates the default loader for gateway protocols | [
"NewLoader",
"creates",
"the",
"default",
"loader",
"for",
"gateway",
"protocols"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/config/loader.go#L33-L77 |
140,482 | signalfx/gateway | config/loader.go | Forwarder | func (l *Loader) Forwarder(conf *ForwardTo) (protocol.Forwarder, error) {
if conf.Type == "" {
return nil, errors.New("type required to load config")
}
if l, exists := l.forwarders[conf.Type]; exists {
return l.Forwarder(conf)
}
return nil, errors.Errorf("cannot find config %s", conf.Type)
} | go | func (l *Loader) Forwarder(conf *ForwardTo) (protocol.Forwarder, error) {
if conf.Type == "" {
return nil, errors.New("type required to load config")
}
if l, exists := l.forwarders[conf.Type]; exists {
return l.Forwarder(conf)
}
return nil, errors.Errorf("cannot find config %s", conf.Type)
} | [
"func",
"(",
"l",
"*",
"Loader",
")",
"Forwarder",
"(",
"conf",
"*",
"ForwardTo",
")",
"(",
"protocol",
".",
"Forwarder",
",",
"error",
")",
"{",
"if",
"conf",
".",
"Type",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"... | // Forwarder loads a forwarder based upon config, finding the right forwarder first | [
"Forwarder",
"loads",
"a",
"forwarder",
"based",
"upon",
"config",
"finding",
"the",
"right",
"forwarder",
"first"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/config/loader.go#L87-L95 |
140,483 | signalfx/gateway | config/loader.go | Listener | func (l *Loader) Listener(sink signalfx.Sink, conf *ListenFrom) (protocol.Listener, error) {
if conf.Type == "" {
return nil, errors.New("type required to load config")
}
wrappedSink := sink
for _, w := range l.listenWrappers {
wrappedSink = w.WrapSink(wrappedSink, conf)
}
if l, exists := l.listeners[conf.Typ... | go | func (l *Loader) Listener(sink signalfx.Sink, conf *ListenFrom) (protocol.Listener, error) {
if conf.Type == "" {
return nil, errors.New("type required to load config")
}
wrappedSink := sink
for _, w := range l.listenWrappers {
wrappedSink = w.WrapSink(wrappedSink, conf)
}
if l, exists := l.listeners[conf.Typ... | [
"func",
"(",
"l",
"*",
"Loader",
")",
"Listener",
"(",
"sink",
"signalfx",
".",
"Sink",
",",
"conf",
"*",
"ListenFrom",
")",
"(",
"protocol",
".",
"Listener",
",",
"error",
")",
"{",
"if",
"conf",
".",
"Type",
"==",
"\"",
"\"",
"{",
"return",
"nil"... | // Listener loads a listener based upon config, finding the right listener first | [
"Listener",
"loads",
"a",
"listener",
"based",
"upon",
"config",
"finding",
"the",
"right",
"listener",
"first"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/config/loader.go#L98-L110 |
140,484 | signalfx/gateway | protocol/healthcheck.go | HealthDatapoints | func (c *CloseableHealthCheck) HealthDatapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{sfxclient.Cumulative("total_health_checks", nil, atomic.LoadInt64(&c.totalHealthChecks))}
} | go | func (c *CloseableHealthCheck) HealthDatapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{sfxclient.Cumulative("total_health_checks", nil, atomic.LoadInt64(&c.totalHealthChecks))}
} | [
"func",
"(",
"c",
"*",
"CloseableHealthCheck",
")",
"HealthDatapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"sfxclient",
".",
"Cumulative",
"(",
"\"",
"\"",
",",
"nil",... | // HealthDatapoints returns the total health checks done | [
"HealthDatapoints",
"returns",
"the",
"total",
"health",
"checks",
"done"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/healthcheck.go#L24-L26 |
140,485 | signalfx/gateway | protocol/healthcheck.go | SetupHealthCheck | func (c *CloseableHealthCheck) SetupHealthCheck(healthCheck *string, r *mux.Router, logger log.Logger) {
f := http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
atomic.AddInt64(&c.totalHealthChecks, 1)
if atomic.LoadInt32(&c.setCloseHeader) != 0 {
rw.Header().Set("Connection", "Close")
rw.Write... | go | func (c *CloseableHealthCheck) SetupHealthCheck(healthCheck *string, r *mux.Router, logger log.Logger) {
f := http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
atomic.AddInt64(&c.totalHealthChecks, 1)
if atomic.LoadInt32(&c.setCloseHeader) != 0 {
rw.Header().Set("Connection", "Close")
rw.Write... | [
"func",
"(",
"c",
"*",
"CloseableHealthCheck",
")",
"SetupHealthCheck",
"(",
"healthCheck",
"*",
"string",
",",
"r",
"*",
"mux",
".",
"Router",
",",
"logger",
"log",
".",
"Logger",
")",
"{",
"f",
":=",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"rw"... | // SetupHealthCheck sets up a closeable healthcheck, when open returns 200, when closed returns 404 and close the connection | [
"SetupHealthCheck",
"sets",
"up",
"a",
"closeable",
"healthcheck",
"when",
"open",
"returns",
"200",
"when",
"closed",
"returns",
"404",
"and",
"close",
"the",
"connection"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/healthcheck.go#L29-L43 |
140,486 | signalfx/gateway | protocol/signalfx/tagreplace/tagreplace.go | AddSpans | func (t *TagReplace) AddSpans(ctx context.Context, spans []*trace.Span) error {
for _, s := range spans {
if s.Name != nil {
for _, r := range t.rules {
nms := r.SubexpNames()
oldName := *s.Name
if ms := r.FindStringSubmatch(oldName); ms != nil {
ims := r.FindStringSubmatchIndex(oldName)
va... | go | func (t *TagReplace) AddSpans(ctx context.Context, spans []*trace.Span) error {
for _, s := range spans {
if s.Name != nil {
for _, r := range t.rules {
nms := r.SubexpNames()
oldName := *s.Name
if ms := r.FindStringSubmatch(oldName); ms != nil {
ims := r.FindStringSubmatchIndex(oldName)
va... | [
"func",
"(",
"t",
"*",
"TagReplace",
")",
"AddSpans",
"(",
"ctx",
"context",
".",
"Context",
",",
"spans",
"[",
"]",
"*",
"trace",
".",
"Span",
")",
"error",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"spans",
"{",
"if",
"s",
".",
"Name",
"!=",
... | // AddSpans maps all rules to all spans and does the replacements, this can be VERY expensive, and modifies the spans
// if exitEarly is true, will only apply the first rule that matches | [
"AddSpans",
"maps",
"all",
"rules",
"to",
"all",
"spans",
"and",
"does",
"the",
"replacements",
"this",
"can",
"be",
"VERY",
"expensive",
"and",
"modifies",
"the",
"spans",
"if",
"exitEarly",
"is",
"true",
"will",
"only",
"apply",
"the",
"first",
"rule",
"... | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/tagreplace/tagreplace.go#L42-L74 |
140,487 | signalfx/gateway | protocol/signalfx/tagreplace/tagreplace.go | New | func New(ruleStrings []string, exitEarly bool, next sink) (*TagReplace, error) {
var rules []*regexp.Regexp
for _, r := range ruleStrings {
var err error
var rp *regexp.Regexp
if rp, err = regexp.Compile(r); err != nil {
return nil, err
}
if len(rp.SubexpNames()) < 2 {
return nil, fmt.Errorf("regex co... | go | func New(ruleStrings []string, exitEarly bool, next sink) (*TagReplace, error) {
var rules []*regexp.Regexp
for _, r := range ruleStrings {
var err error
var rp *regexp.Regexp
if rp, err = regexp.Compile(r); err != nil {
return nil, err
}
if len(rp.SubexpNames()) < 2 {
return nil, fmt.Errorf("regex co... | [
"func",
"New",
"(",
"ruleStrings",
"[",
"]",
"string",
",",
"exitEarly",
"bool",
",",
"next",
"sink",
")",
"(",
"*",
"TagReplace",
",",
"error",
")",
"{",
"var",
"rules",
"[",
"]",
"*",
"regexp",
".",
"Regexp",
"\n",
"for",
"_",
",",
"r",
":=",
"... | // New returns you a new TagReplace object | [
"New",
"returns",
"you",
"a",
"new",
"TagReplace",
"object"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/tagreplace/tagreplace.go#L77-L101 |
140,488 | signalfx/gateway | internal-metrics/internal.go | NewCollector | func NewCollector(logger log.Logger, scheduler *sfxclient.Scheduler) *Collector {
return &Collector{
scheduler: scheduler,
logger: logger,
jsonfunc: json.Marshal,
}
} | go | func NewCollector(logger log.Logger, scheduler *sfxclient.Scheduler) *Collector {
return &Collector{
scheduler: scheduler,
logger: logger,
jsonfunc: json.Marshal,
}
} | [
"func",
"NewCollector",
"(",
"logger",
"log",
".",
"Logger",
",",
"scheduler",
"*",
"sfxclient",
".",
"Scheduler",
")",
"*",
"Collector",
"{",
"return",
"&",
"Collector",
"{",
"scheduler",
":",
"scheduler",
",",
"logger",
":",
"logger",
",",
"jsonfunc",
":... | // NewCollector gets you the new Collector | [
"NewCollector",
"gets",
"you",
"the",
"new",
"Collector"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/internal-metrics/internal.go#L19-L25 |
140,489 | signalfx/gateway | internal-metrics/internal.go | MetricsHandler | func (c *Collector) MetricsHandler(w http.ResponseWriter, req *http.Request) {
dps := c.scheduler.CollectDatapoints()
b, err := c.jsonfunc(dps)
if err == nil {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Content-Length", strconv.Itoa(len(b)))
_, err = w.Write(b)
}
if err != nil {
htt... | go | func (c *Collector) MetricsHandler(w http.ResponseWriter, req *http.Request) {
dps := c.scheduler.CollectDatapoints()
b, err := c.jsonfunc(dps)
if err == nil {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Content-Length", strconv.Itoa(len(b)))
_, err = w.Write(b)
}
if err != nil {
htt... | [
"func",
"(",
"c",
"*",
"Collector",
")",
"MetricsHandler",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"dps",
":=",
"c",
".",
"scheduler",
".",
"CollectDatapoints",
"(",
")",
"\n",
"b",
",",
"err",
":="... | // MetricsHandler exposes a handler func | [
"MetricsHandler",
"exposes",
"a",
"handler",
"func"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/internal-metrics/internal.go#L28-L39 |
140,490 | signalfx/gateway | protocol/filtering/filtering.go | Setup | func (f *FilteredForwarder) Setup(filters *FilterObj) error {
if filters != nil {
allows := make([]*regexp.Regexp, len(filters.Allow))
denys := make([]*regexp.Regexp, len(filters.Deny))
for i, a := range filters.Allow {
ra, err := regexp.Compile(a)
if err != nil {
return err
}
allows[i] = ra
}
... | go | func (f *FilteredForwarder) Setup(filters *FilterObj) error {
if filters != nil {
allows := make([]*regexp.Regexp, len(filters.Allow))
denys := make([]*regexp.Regexp, len(filters.Deny))
for i, a := range filters.Allow {
ra, err := regexp.Compile(a)
if err != nil {
return err
}
allows[i] = ra
}
... | [
"func",
"(",
"f",
"*",
"FilteredForwarder",
")",
"Setup",
"(",
"filters",
"*",
"FilterObj",
")",
"error",
"{",
"if",
"filters",
"!=",
"nil",
"{",
"allows",
":=",
"make",
"(",
"[",
"]",
"*",
"regexp",
".",
"Regexp",
",",
"len",
"(",
"filters",
".",
... | // Setup the FilteredForwarder based on the FilteredForwarderConfig | [
"Setup",
"the",
"FilteredForwarder",
"based",
"on",
"the",
"FilteredForwarderConfig"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/filtering/filtering.go#L24-L46 |
140,491 | signalfx/gateway | protocol/filtering/filtering.go | FilterMetricName | func (f *FilteredForwarder) FilterMetricName(metricName string) bool {
denied := false
for _, a := range f.deny {
if a.Match([]byte(metricName)) {
denied = true
break
}
}
found := false
for _, a := range f.allow {
if a.Match([]byte(metricName)) {
denied = false
found = true
break
}
}
retur... | go | func (f *FilteredForwarder) FilterMetricName(metricName string) bool {
denied := false
for _, a := range f.deny {
if a.Match([]byte(metricName)) {
denied = true
break
}
}
found := false
for _, a := range f.allow {
if a.Match([]byte(metricName)) {
denied = false
found = true
break
}
}
retur... | [
"func",
"(",
"f",
"*",
"FilteredForwarder",
")",
"FilterMetricName",
"(",
"metricName",
"string",
")",
"bool",
"{",
"denied",
":=",
"false",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"f",
".",
"deny",
"{",
"if",
"a",
".",
"Match",
"(",
"[",
"]",
"... | // FilterMetricName returns true for a metric which matches allow, or if no allow rules are present,
// if it didn't match deny. Returns false otherwise. | [
"FilterMetricName",
"returns",
"true",
"for",
"a",
"metric",
"which",
"matches",
"allow",
"or",
"if",
"no",
"allow",
"rules",
"are",
"present",
"if",
"it",
"didn",
"t",
"match",
"deny",
".",
"Returns",
"false",
"otherwise",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/filtering/filtering.go#L50-L67 |
140,492 | signalfx/gateway | protocol/filtering/filtering.go | FilterDatapoints | func (f *FilteredForwarder) FilterDatapoints(datapoints []*datapoint.Datapoint) []*datapoint.Datapoint {
// TODO use a sync.pool of buffers here
// TODO if we spun this off into several go routines instead of doing this in the main forwarder thread we could do a lot more work
validDatapoints := make([]*datapoint.Dat... | go | func (f *FilteredForwarder) FilterDatapoints(datapoints []*datapoint.Datapoint) []*datapoint.Datapoint {
// TODO use a sync.pool of buffers here
// TODO if we spun this off into several go routines instead of doing this in the main forwarder thread we could do a lot more work
validDatapoints := make([]*datapoint.Dat... | [
"func",
"(",
"f",
"*",
"FilteredForwarder",
")",
"FilterDatapoints",
"(",
"datapoints",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"// TODO use a sync.pool of buffers here",
"// TODO if we spun this off into s... | // FilterDatapoints filters datapoints based on the metric name as well as counts how many it filters | [
"FilterDatapoints",
"filters",
"datapoints",
"based",
"on",
"the",
"metric",
"name",
"as",
"well",
"as",
"counts",
"how",
"many",
"it",
"filters"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/filtering/filtering.go#L70-L82 |
140,493 | signalfx/gateway | protocol/filtering/filtering.go | GetFilteredDatapoints | func (f *FilteredForwarder) GetFilteredDatapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{sfxclient.Cumulative("filtered_by_forwarder", nil, atomic.LoadInt64(&f.FilteredDatapoints))}
} | go | func (f *FilteredForwarder) GetFilteredDatapoints() []*datapoint.Datapoint {
return []*datapoint.Datapoint{sfxclient.Cumulative("filtered_by_forwarder", nil, atomic.LoadInt64(&f.FilteredDatapoints))}
} | [
"func",
"(",
"f",
"*",
"FilteredForwarder",
")",
"GetFilteredDatapoints",
"(",
")",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"return",
"[",
"]",
"*",
"datapoint",
".",
"Datapoint",
"{",
"sfxclient",
".",
"Cumulative",
"(",
"\"",
"\"",
",",
"nil... | // GetFilteredDatapoints returns a cumulative counter of how many datapoints were filtered by this forwarder | [
"GetFilteredDatapoints",
"returns",
"a",
"cumulative",
"counter",
"of",
"how",
"many",
"datapoints",
"were",
"filtered",
"by",
"this",
"forwarder"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/filtering/filtering.go#L85-L87 |
140,494 | signalfx/gateway | protocol/signalfx/trace_zipkin.go | fromZipkinV2 | func (is *InputSpan) fromZipkinV2() (*trace.Span, error) {
// Do some basic validation
if len(is.BinaryAnnotations) > 0 {
return nil, errors.New("span cannot have binaryAnnotations with Zipkin V2 fields")
}
if len(is.Annotations) > 0 {
is.Span.Annotations = make([]*trace.Annotation, len(is.Annotations))
for ... | go | func (is *InputSpan) fromZipkinV2() (*trace.Span, error) {
// Do some basic validation
if len(is.BinaryAnnotations) > 0 {
return nil, errors.New("span cannot have binaryAnnotations with Zipkin V2 fields")
}
if len(is.Annotations) > 0 {
is.Span.Annotations = make([]*trace.Annotation, len(is.Annotations))
for ... | [
"func",
"(",
"is",
"*",
"InputSpan",
")",
"fromZipkinV2",
"(",
")",
"(",
"*",
"trace",
".",
"Span",
",",
"error",
")",
"{",
"// Do some basic validation",
"if",
"len",
"(",
"is",
".",
"BinaryAnnotations",
")",
">",
"0",
"{",
"return",
"nil",
",",
"erro... | // asZipkinV2 shortcuts the span conversion process and treats the InputSpan as
// ZipkinV2 and returns that span directly. | [
"asZipkinV2",
"shortcuts",
"the",
"span",
"conversion",
"process",
"and",
"treats",
"the",
"InputSpan",
"as",
"ZipkinV2",
"and",
"returns",
"that",
"span",
"directly",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/trace_zipkin.go#L52-L67 |
140,495 | signalfx/gateway | protocol/signalfx/trace_zipkin.go | handleOnlyAddressAnnotations | func (sb *spanBuilder) handleOnlyAddressAnnotations(is *InputSpan, ca, sa *trace.Endpoint) bool {
if sb.cs == nil && sb.sr == nil && ca != nil && sa != nil {
sb.spanForEndpoint(is, ca).RemoteEndpoint = sa
return true
}
return false
} | go | func (sb *spanBuilder) handleOnlyAddressAnnotations(is *InputSpan, ca, sa *trace.Endpoint) bool {
if sb.cs == nil && sb.sr == nil && ca != nil && sa != nil {
sb.spanForEndpoint(is, ca).RemoteEndpoint = sa
return true
}
return false
} | [
"func",
"(",
"sb",
"*",
"spanBuilder",
")",
"handleOnlyAddressAnnotations",
"(",
"is",
"*",
"InputSpan",
",",
"ca",
",",
"sa",
"*",
"trace",
".",
"Endpoint",
")",
"bool",
"{",
"if",
"sb",
".",
"cs",
"==",
"nil",
"&&",
"sb",
".",
"sr",
"==",
"nil",
... | // special-case when we are missing core annotations, but we have both address annotations | [
"special",
"-",
"case",
"when",
"we",
"are",
"missing",
"core",
"annotations",
"but",
"we",
"have",
"both",
"address",
"annotations"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/trace_zipkin.go#L448-L454 |
140,496 | signalfx/gateway | protocol/signalfx/trace_zipkin.go | ToError | func (te *traceErrs) ToError(err error) error {
if te == nil {
return err
}
return te
} | go | func (te *traceErrs) ToError(err error) error {
if te == nil {
return err
}
return te
} | [
"func",
"(",
"te",
"*",
"traceErrs",
")",
"ToError",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"te",
"==",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"te",
"\n",
"}"
] | // ToError returns the err object if the it has not been instantiated, and itself if it has
// we do this because err is possibly a response from sbingest which could be a json response
// and we want to pass this on unmolested but encoding errors are more important so send them
// if they exist | [
"ToError",
"returns",
"the",
"err",
"object",
"if",
"the",
"it",
"has",
"not",
"been",
"instantiated",
"and",
"itself",
"if",
"it",
"has",
"we",
"do",
"this",
"because",
"err",
"is",
"possibly",
"a",
"response",
"from",
"sbingest",
"which",
"could",
"be",
... | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/trace_zipkin.go#L507-L512 |
140,497 | signalfx/gateway | protocol/signalfx/trace_zipkin.go | normalizeParentSpanID | func normalizeParentSpanID(parentSpanID *string) *string {
if parentSpanID != nil && strings.Count(*parentSpanID, "0") == len(*parentSpanID) {
return nil
}
return parentSpanID
} | go | func normalizeParentSpanID(parentSpanID *string) *string {
if parentSpanID != nil && strings.Count(*parentSpanID, "0") == len(*parentSpanID) {
return nil
}
return parentSpanID
} | [
"func",
"normalizeParentSpanID",
"(",
"parentSpanID",
"*",
"string",
")",
"*",
"string",
"{",
"if",
"parentSpanID",
"!=",
"nil",
"&&",
"strings",
".",
"Count",
"(",
"*",
"parentSpanID",
",",
"\"",
"\"",
")",
"==",
"len",
"(",
"*",
"parentSpanID",
")",
"{... | // A parentSpanID of all hex 0s should be normalized to nil. | [
"A",
"parentSpanID",
"of",
"all",
"hex",
"0s",
"should",
"be",
"normalized",
"to",
"nil",
"."
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/trace_zipkin.go#L534-L539 |
140,498 | signalfx/gateway | protocol/signalfx/trace_zipkin.go | Read | func (decoder *JSONTraceDecoderV1) Read(ctx context.Context, req *http.Request) error {
var input signalfxformat.InputSpanList
if err := easyjson.UnmarshalFromReader(req.Body, &input); err != nil {
return errInvalidJSONTraceFormat
}
if len(input) == 0 {
return nil
}
spans := make([]*trace.Span, 0, len(input... | go | func (decoder *JSONTraceDecoderV1) Read(ctx context.Context, req *http.Request) error {
var input signalfxformat.InputSpanList
if err := easyjson.UnmarshalFromReader(req.Body, &input); err != nil {
return errInvalidJSONTraceFormat
}
if len(input) == 0 {
return nil
}
spans := make([]*trace.Span, 0, len(input... | [
"func",
"(",
"decoder",
"*",
"JSONTraceDecoderV1",
")",
"Read",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"var",
"input",
"signalfxformat",
".",
"InputSpanList",
"\n",
"if",
"err",
":=",
"easyjson",
... | // Read the data off the wire in json format | [
"Read",
"the",
"data",
"off",
"the",
"wire",
"in",
"json",
"format"
] | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/signalfx/trace_zipkin.go#L550-L591 |
140,499 | signalfx/gateway | protocol/collectd/collectd.go | NewDatapoint | func NewDatapoint(point *JSONWriteFormat, index uint, defaultDimensions map[string]string) *datapoint.Datapoint {
dstype, val, dsname := point.Dstypes[index], point.Values[index], point.Dsnames[index]
// if you add another dimension that we read from the json update this number
const MaxCollectDDims = 6
dimensions... | go | func NewDatapoint(point *JSONWriteFormat, index uint, defaultDimensions map[string]string) *datapoint.Datapoint {
dstype, val, dsname := point.Dstypes[index], point.Values[index], point.Dsnames[index]
// if you add another dimension that we read from the json update this number
const MaxCollectDDims = 6
dimensions... | [
"func",
"NewDatapoint",
"(",
"point",
"*",
"JSONWriteFormat",
",",
"index",
"uint",
",",
"defaultDimensions",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"datapoint",
".",
"Datapoint",
"{",
"dstype",
",",
"val",
",",
"dsname",
":=",
"point",
".",
"Dstyp... | // NewDatapoint creates a new datapoint from collectd's write_http endpoint JSON format
// defaultDimensions are added to the datapoint created, but will be overridden by any dimension
// values in the JSON
// Dimensions are pulled out of type_instance, plugin_instance and host in that order of precedence | [
"NewDatapoint",
"creates",
"a",
"new",
"datapoint",
"from",
"collectd",
"s",
"write_http",
"endpoint",
"JSON",
"format",
"defaultDimensions",
"are",
"added",
"to",
"the",
"datapoint",
"created",
"but",
"will",
"be",
"overridden",
"by",
"any",
"dimension",
"values"... | 60f8886d9dbf529d974d8f3c0b9e932d8a7570a0 | https://github.com/signalfx/gateway/blob/60f8886d9dbf529d974d8f3c0b9e932d8a7570a0/protocol/collectd/collectd.go#L45-L71 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.