// Configure Override *baseCollector.Configure(); will fetch the whitelisted processes
func (s *SmemStats) Configure(configMap map[string]interface{}) {
s.configureCommonParams(configMap)
if user, exists := configMap["user"]; exists {
s.user = user.(string)
} else {
s.log.Warn("Required config does not exist for SmemStats: user")
}
if whitelist, exists := configMap["procsWhitelist"]; exists {
s.whitelistedProcs = whitelist.(string)
} else {
s.log.Warn("Required config does not exist for SmemStats: procsWhitelist")
}
if smemPath, exists := configMap["smemPath"]; exists {
s.smemPath = smemPath.(string)
} else {
s.log.Warn("Required config does not exist for SmemStats: smemPath")
}
if blacklist, exists := configMap["metricsBlacklist"]; exists {
s.whitelistedMetrics = getWhitelistedMetrics(config.GetAsSlice(blacklist))
} else {
s.whitelistedMetrics = allMetrics
}
if dimensionsFromCmdline, exists := configMap["dimensionsFromCmdline"]; exists {
s.dimensionsFromCmdline = config.GetAsMap(dimensionsFromCmdline)
}
if dimensionsFromEnv, exists := configMap["dimensionsFromEnv"]; exists {
s.dimensionsFromEnv = config.GetAsMap(dimensionsFromEnv)
}
}
// Configure takes a dictionary of values with which the handler can configure itself.
func (d *DockerStats) Configure(configMap map[string]interface{}) {
if timeout, exists := configMap["dockerStatsTimeout"]; exists {
d.statsTimeout = min(config.GetAsInt(timeout, d.interval), d.interval)
} else {
d.statsTimeout = d.interval
}
if dockerEndpoint, exists := configMap["dockerEndPoint"]; exists {
if str, ok := dockerEndpoint.(string); ok {
d.endpoint = str
} else {
d.log.Warn("Failed to cast dokerEndPoint: ", reflect.TypeOf(dockerEndpoint))
}
} else {
d.endpoint = endpoint
}
d.dockerClient, _ = docker.NewClient(d.endpoint)
if generatedDimensions, exists := configMap["generatedDimensions"]; exists {
for dimension, generator := range generatedDimensions.(map[string]interface{}) {
for key, regx := range config.GetAsMap(generator) {
re, err := regexp.Compile(regx)
if err != nil {
d.log.Warn("Failed to compile regex: ", regx, err)
} else {
d.compiledRegex[dimension] = &Regex{regex: re, tag: key}
}
}
}
}
d.configureCommonParams(configMap)
if skipRegex, skipExists := configMap["skipContainerRegex"]; skipExists {
d.skipRegex = regexp.MustCompile(skipRegex.(string))
}
}
// Configure this takes a dictionary of values with which the handler can configure itself
func (ps *ProcStatus) Configure(configMap map[string]interface{}) {
if pattern, exists := configMap["pattern"]; exists {
re, err := regexp.Compile(pattern.(string))
if err != nil {
ps.log.Warn("Failed to compile regex: ", err)
} else {
ps.pattern = re
}
}
if matchCommandLine, exists := configMap["matchCommandLine"]; exists {
ps.matchCommandLine = matchCommandLine.(bool)
}
if generatedDimensions, exists := configMap["generatedDimensions"]; exists {
for dimension, generator := range config.GetAsMap(generatedDimensions) {
//don't use MustCompile otherwise program will panic due to misformated regex
re, err := regexp.Compile(generator)
if err != nil {
ps.log.Warn("Failed to compile regex: ", generator, err)
} else {
ps.compiledRegex[dimension] = re
}
}
}
ps.configureCommonParams(configMap)
}
// configureCommonParams will extract the common parameters that are used and set them in the handler
func (base *BaseHandler) configureCommonParams(configMap map[string]interface{}) {
if asInterface, exists := configMap["timeout"]; exists {
timeout := config.GetAsFloat(asInterface, DefaultTimeoutSec)
base.timeout = time.Duration(timeout) * time.Second
}
if asInterface, exists := configMap["max_buffer_size"]; exists {
base.maxBufferSize = config.GetAsInt(asInterface, DefaultBufferSize)
}
if asInterface, exists := configMap["interval"]; exists {
base.interval = config.GetAsInt(asInterface, DefaultInterval)
}
// Default dimensions can be extended or overridden on a per handler basis.
if asInterface, exists := configMap["defaultDimensions"]; exists {
handlerLevelDimensions := config.GetAsMap(asInterface)
base.SetDefaultDimensions(handlerLevelDimensions)
}
if asInterface, exists := configMap["keepAliveInterval"]; exists {
keepAliveInterval := config.GetAsInt(asInterface, DefaultKeepAliveInterval)
base.SetKeepAliveInterval(keepAliveInterval)
}
if asInterface, exists := configMap["maxIdleConnectionsPerHost"]; exists {
maxIdleConnectionsPerHost := config.GetAsInt(asInterface,
DefaultMaxIdleConnectionsPerHost)
base.SetMaxIdleConnectionsPerHost(maxIdleConnectionsPerHost)
}
}
func TestGetAsMap(t *testing.T) {
assert := assert.New(t)
// Test if string can be converted to map[string]string
stringToParse := "{\"runtimeenv\" : \"dev\", \"region\":\"uswest1-devc\"}"
expectedValue := map[string]string{
"runtimeenv": "dev",
"region": "uswest1-devc",
}
assert.Equal(config.GetAsMap(stringToParse), expectedValue)
// Test if map[string]interface{} can be converted to map[string]string
interfaceMapToParse := make(map[string]interface{})
interfaceMapToParse["runtimeenv"] = "dev"
interfaceMapToParse["region"] = "uswest1-devc"
assert.Equal(config.GetAsMap(interfaceMapToParse), expectedValue)
}
// Configure Override *baseCollector.Configure(). Will create the required MesosLeaderElect instance.
func (m *MesosSlaveStats) Configure(configMap map[string]interface{}) {
m.configureCommonParams(configMap)
c := config.GetAsMap(configMap)
if httpTimeout, exists := c["httpTimeout"]; exists {
m.client.Timeout = time.Duration(config.GetAsInt(httpTimeout, httpDefaultTimeout)) * time.Second
}
if slaveSnapshotPort, exists := c["slaveSnapshotPort"]; exists {
m.snapshotPort = config.GetAsInt(slaveSnapshotPort, mesosDefaultSlaveSnapshotPort)
}
}
// Configure Override *baseCollector.Configure(). Will create the required MesosLeaderElect instance.
func (m *MesosStats) Configure(configMap map[string]interface{}) {
m.configureCommonParams(configMap)
c := config.GetAsMap(configMap)
if mesosNodes, exists := c["mesosNodes"]; exists && len(mesosNodes) > 0 {
m.mesosCache = newMLE()
m.mesosCache.Configure(mesosNodes, cacheTimeout)
} else {
m.log.Error("Require configuration not found: mesosNodes")
return
}
}
// Configure takes a dictionary of values with which the handler can configure itself.
func (d *DockerStats) Configure(configMap map[string]interface{}) {
if timeout, exists := configMap["dockerStatsTimeout"]; exists {
d.statsTimeout = min(config.GetAsInt(timeout, d.interval), d.interval)
} else {
d.statsTimeout = d.interval
}
if generatedDimensions, exists := configMap["generatedDimensions"]; exists {
for dimension, generator := range generatedDimensions.(map[string]interface{}) {
for key, regx := range config.GetAsMap(generator) {
re, err := regexp.Compile(regx)
if err != nil {
d.log.Warn("Failed to compile regex: ", regx, err)
} else {
d.compiledRegex[dimension] = &Regex{regex: re, tag: key}
}
}
}
}
d.configureCommonParams(configMap)
}
