func Publish(event *schema.ProbeEvent) error {
if !enabled {
return nil
}
id := time.Now().UnixNano()
data, err := msg.CreateProbeEventMsg(event, id, msg.FormatProbeEventMsgp)
if err != nil {
log.Fatal(4, "Fatal error creating event message: %s", err)
}
collectorEventPublisherMsgs.Inc(1)
err = globalProducer.Publish(topic, data)
if err != nil {
log.Fatal(4, "can't publish to nsqd: %s", err)
}
log.Debug("event published to NSQ %d", id)
return nil
}
func SendEmail(cmd *m.SendEmailCommand) error {
if !setting.Smtp.Enabled {
return errors.New("Worldping mailing/smtp options not configured, contact your network admin")
}
if mailTemplates == nil {
log.Fatal(4, "email templates not yet initialized.")
}
var buffer bytes.Buffer
var err error
var subjectText interface{}
data := cmd.Data
if data == nil {
data = make(map[string]interface{}, 10)
}
setDefaultTemplateData(data)
err = mailTemplates.ExecuteTemplate(&buffer, cmd.Template, data)
if err != nil {
return err
}
subjectData := data["Subject"].(map[string]interface{})
subjectText, hasSubject := subjectData["value"]
if !hasSubject {
return errors.New(fmt.Sprintf("Missing subject in Template %s", cmd.Template))
}
subjectTmpl, err := template.New("subject").Parse(subjectText.(string))
if err != nil {
return err
}
var subjectBuffer bytes.Buffer
err = subjectTmpl.ExecuteTemplate(&subjectBuffer, "subject", data)
if err != nil {
return err
}
addToMailQueue(&Message{
To: cmd.To,
From: setting.Smtp.FromAddress,
Subject: subjectBuffer.String(),
Body: buffer.String(),
})
return nil
}
func parseAppUrlAndSubUrl(section *ini.Section) (string, string) {
appUrl := section.Key("root_url").MustString("http://localhost:3000/")
if appUrl[len(appUrl)-1] != '/' {
appUrl += "/"
}
// Check if has app suburl.
url, err := url.Parse(appUrl)
if err != nil {
log.Fatal(4, "Invalid root_url(%s): %s", appUrl, err)
}
appSubUrl := strings.TrimSuffix(url.Path, "/")
return appUrl, appSubUrl
}
func getCommandLineProperties(args []string) map[string]string {
props := make(map[string]string)
for _, arg := range args {
if !strings.HasPrefix(arg, "cfg:") {
continue
}
trimmed := strings.TrimPrefix(arg, "cfg:")
parts := strings.Split(trimmed, "=")
if len(parts) != 2 {
log.Fatal(3, "Invalid command line argument", arg)
return nil
}
props[parts[0]] = parts[1]
}
return props
}
func Init(metrics met.Backend) {
sec := setting.Cfg.Section("collector_event_publisher")
if !sec.Key("enabled").MustBool(false) {
enabled = false
return
}
enabled = true
addr := sec.Key("nsqd_addr").MustString("localhost:4150")
topic = sec.Key("topic").MustString("metrics")
cfg := nsq.NewConfig()
cfg.UserAgent = fmt.Sprintf("probe-ctrl")
var err error
globalProducer, err = nsq.NewProducer(addr, cfg)
if err != nil {
log.Fatal(0, "failed to initialize nsq producer.", err)
}
collectorEventPublisherMsgs = metrics.NewCount("collectoreventpublisher.events-published")
}
func loadConfiguration(args *CommandLineArgs) {
var err error
// load config defaults
defaultConfigFile := path.Join(HomePath, "conf/defaults.ini")
configFiles = append(configFiles, defaultConfigFile)
Cfg, err = ini.Load(defaultConfigFile)
Cfg.BlockMode = false
if err != nil {
log.Fatal(3, "Failed to parse defaults.ini, %v", err)
}
// command line props
commandLineProps := getCommandLineProperties(args.Args)
// load default overrides
applyCommandLineDefaultProperties(commandLineProps)
// init logging before specific config so we can log errors from here on
DataPath = makeAbsolute(Cfg.Section("paths").Key("data").String(), HomePath)
initLogging(args)
// load specified config file
loadSpecifedConfigFile(args.Config)
// apply environment overrides
applyEnvVariableOverrides()
// apply command line overrides
applyCommandLineProperties(commandLineProps)
// evaluate config values containing environment variables
evalConfigValues()
// update data path and logging config
DataPath = makeAbsolute(Cfg.Section("paths").Key("data").String(), HomePath)
initLogging(args)
}
func loadSpecifedConfigFile(configFile string) {
if configFile == "" {
configFile = filepath.Join(HomePath, "conf/custom.ini")
// return without error if custom file does not exist
if !pathExists(configFile) {
return
}
}
userConfig, err := ini.Load(configFile)
userConfig.BlockMode = false
if err != nil {
log.Fatal(3, "Failed to parse %v, %v", configFile, err)
}
for _, section := range userConfig.Sections() {
for _, key := range section.Keys() {
if key.Value() == "" {
continue
}
defaultSec, err := Cfg.GetSection(section.Name())
if err != nil {
log.Error(3, "Unknown config section %s defined in %s", section.Name(), configFile)
continue
}
defaultKey, err := defaultSec.GetKey(key.Name())
if err != nil {
log.Error(3, "Unknown config key %s defined in section %s, in file %s", key.Name(), section.Name(), configFile)
continue
}
defaultKey.SetValue(key.Value())
}
}
configFiles = append(configFiles, configFile)
}
func initLogging(args *CommandLineArgs) {
//close any existing log handlers.
log.Close()
// Get and check log mode.
LogModes = strings.Split(Cfg.Section("log").Key("mode").MustString("console"), ",")
LogsPath = makeAbsolute(Cfg.Section("paths").Key("logs").String(), HomePath)
LogConfigs = make([]util.DynMap, len(LogModes))
for i, mode := range LogModes {
mode = strings.TrimSpace(mode)
sec, err := Cfg.GetSection("log." + mode)
if err != nil {
log.Fatal(4, "Unknown log mode: %s", mode)
}
// Log level.
levelName := Cfg.Section("log."+mode).Key("level").In("Trace",
[]string{"Trace", "Debug", "Info", "Warn", "Error", "Critical"})
level, ok := logLevels[levelName]
if !ok {
log.Fatal(4, "Unknown log level: %s", levelName)
}
// Generate log configuration.
switch mode {
case "console":
formatting := sec.Key("formatting").MustBool(true)
LogConfigs[i] = util.DynMap{
"level": level,
"formatting": formatting,
}
case "file":
logPath := sec.Key("file_name").MustString(filepath.Join(LogsPath, "grafana.log"))
os.MkdirAll(filepath.Dir(logPath), os.ModePerm)
LogConfigs[i] = util.DynMap{
"level": level,
"filename": logPath,
"rotate": sec.Key("log_rotate").MustBool(true),
"maxlines": sec.Key("max_lines").MustInt(1000000),
"maxsize": 1 << uint(sec.Key("max_size_shift").MustInt(28)),
"daily": sec.Key("daily_rotate").MustBool(true),
"maxdays": sec.Key("max_days").MustInt(7),
}
case "conn":
LogConfigs[i] = util.DynMap{
"level": level,
"reconnectOnMsg": sec.Key("reconnect_on_msg").MustBool(),
"reconnect": sec.Key("reconnect").MustBool(),
"net": sec.Key("protocol").In("tcp", []string{"tcp", "unix", "udp"}),
"addr": sec.Key("addr").MustString(":7020"),
}
case "smtp":
LogConfigs[i] = util.DynMap{
"level": level,
"user": sec.Key("user").MustString("*****@*****.**"),
"passwd": sec.Key("passwd").MustString("******"),
"host": sec.Key("host").MustString("127.0.0.1:25"),
"receivers": sec.Key("receivers").MustString("[]"),
"subject": sec.Key("subject").MustString("Diagnostic message from serve"),
}
case "database":
LogConfigs[i] = util.DynMap{
"level": level,
"driver": sec.Key("driver").String(),
"conn": sec.Key("conn").String(),
}
}
cfgJsonBytes, _ := json.Marshal(LogConfigs[i])
log.NewLogger(Cfg.Section("log").Key("buffer_len").MustInt64(10000), mode, string(cfgJsonBytes))
}
}
func NewConfigContext(args *CommandLineArgs) error {
setHomePath(args)
loadConfiguration(args)
Env = Cfg.Section("").Key("app_mode").MustString("development")
InstanceId = Cfg.Section("").Key("instance_id").MustString("default")
server := Cfg.Section("server")
AppUrl, AppSubUrl = parseAppUrlAndSubUrl(server)
Protocol = HTTP
if server.Key("protocol").MustString("http") == "https" {
Protocol = HTTPS
CertFile = server.Key("cert_file").String()
KeyFile = server.Key("cert_key").String()
}
Domain = server.Key("domain").MustString("localhost")
HttpAddr = server.Key("http_addr").MustString("0.0.0.0")
HttpPort = server.Key("http_port").MustString("3000")
RouterLogging = server.Key("router_logging").MustBool(false)
EnableGzip = server.Key("enable_gzip").MustBool(false)
EnforceDomain = server.Key("enforce_domain").MustBool(false)
StaticRootPath = makeAbsolute(server.Key("static_root_path").String(), HomePath)
AdminKey = server.Key("admin_key").String()
GraphiteUrl = Cfg.Section("raintank").Key("graphite_url").MustString("http://localhost:8888/")
if GraphiteUrl[len(GraphiteUrl)-1] != '/' {
GraphiteUrl += "/"
}
// Check if has app suburl.
_, err := url.Parse(GraphiteUrl)
if err != nil {
log.Fatal(4, "Invalid graphite_url(%s): %s", GraphiteUrl, err)
}
ElasticsearchUrl = Cfg.Section("raintank").Key("elasticsearch_url").MustString("http://localhost:9200/")
if ElasticsearchUrl[len(ElasticsearchUrl)-1] != '/' {
ElasticsearchUrl += "/"
}
// Check if has app suburl.
_, err = url.Parse(ElasticsearchUrl)
if err != nil {
log.Fatal(4, "Invalid elasticsearch_url(%s): %s", ElasticsearchUrl, err)
}
alerting := Cfg.Section("alerting")
AlertingEnabled = alerting.Key("enabled").MustBool(false)
TickQueueSize = alerting.Key("tickqueue_size").MustInt(0)
InternalJobQueueSize = alerting.Key("internal_jobqueue_size").MustInt(0)
PreAMQPJobQueueSize = alerting.Key("pre_amqp_jobqueue_size").MustInt(0)
ExecutorLRUSize = alerting.Key("executor_lru_size").MustInt(0)
EnableScheduler = alerting.Key("enable_scheduler").MustBool(true)
WriteIndividualAlertResults = alerting.Key("write_individual_alert_results").MustBool(false)
AlertingInspect = alerting.Key("inspect").MustBool(false)
telemetry := Cfg.Section("telemetry")
StatsdEnabled = telemetry.Key("statsd_enabled").MustBool(false)
StatsdAddr = telemetry.Key("statsd_addr").String()
StatsdType = telemetry.Key("statsd_type").String()
ProfileHeapMB = telemetry.Key("profile_heap_MB").MustInt(0)
ProfileHeapWait = telemetry.Key("profile_heap_wait").MustInt(3600)
ProfileHeapDir = telemetry.Key("profile_heap_dir").MustString("/tmp")
readSmtpSettings()
readQuotaSettings()
readRabbitmqSettings()
return nil
}