Esempio n. 1
0
// QOSEventSend sends an internal CLI event to segment for quality-of-service purposes.
// If the event is an error it also sends the error to rollbar, then displays the
// error to the user and exits non-zero.
func QOSEventSend(system, id string, ep QOSEventProperties) error {
	rollbar.Token = "8481f1ec73f549ce8b81711ca4fdf98a"
	rollbar.Environment = id

	segment := analytics.New("JcNCirASuqEvuWhL8K87JTsUkhY68jvX")

	props := map[string]interface{}{}

	if ep.Error != nil {
		props["error"] = ep.Error.Error()
		rollbar.Error(rollbar.ERR, ep.Error, &rollbar.Field{"id", id})
	}

	if ep.ValidationError != nil {
		props["validation_error"] = ep.ValidationError.Error()
	}

	if ep.AppType != "" {
		props["app_type"] = ep.AppType
	}

	if !ep.Start.IsZero() {
		props["elapsed"] = float64(time.Since(ep.Start).Nanoseconds()) / 1000000
	}

	err := segment.Track(&analytics.Track{
		Event:      system,
		UserId:     id,
		Properties: props,
	})
	if err != nil {
		rollbar.Error(rollbar.ERR, err, &rollbar.Field{"id", id})
	}

	err = segment.Close()
	if err != nil {
		rollbar.Error(rollbar.ERR, err, &rollbar.Field{"id", id})
	}

	if os.Getenv("ROLLBAR_TOKEN") != "" {
		rollbar.Wait()
	}

	if ep.ValidationError != nil {
		return ExitError(ep.ValidationError)
	}

	if ep.Error != nil {
		return ExitError(ep.Error)
	}

	return nil
}
Esempio n. 2
0
func api(at string, handler ApiHandlerFunc) http.HandlerFunc {
	return func(rw http.ResponseWriter, r *http.Request) {
		log := logger.New("ns=kernel").At(at).Start()

		if !passwordCheck(r) {
			rw.Header().Set("WWW-Authenticate", `Basic realm="Convox System"`)
			rw.WriteHeader(401)
			rw.Write([]byte("invalid authorization"))
			return
		}

		if !versionCheck(r) {
			rw.WriteHeader(403)
			rw.Write([]byte("client outdated, please update with `convox update`"))
			return
		}

		err := handler(rw, r)

		if err != nil {
			log.Error(err)
			rollbar.Error(rollbar.ERR, err)
			RenderError(rw, err)
			return
		}

		log.Log("state=success")
	}
}
Esempio n. 3
0
func ws(at string, handler ApiWebsocketFunc) websocket.Handler {
	return websocket.Handler(func(ws *websocket.Conn) {
		log := logger.New("ns=kernel").At(at).Start()

		if !passwordCheck(ws.Request()) {
			ws.Write([]byte("ERROR: invalid authorization\n"))
			return
		}

		if !versionCheck(ws.Request()) {
			ws.Write([]byte("client outdated, please update with `convox update`\n"))
			return
		}

		err := handler(ws)

		if err != nil {
			ws.Write([]byte(fmt.Sprintf("ERROR: %v\n", err)))
			log.Error(err)
			rollbar.Error(rollbar.ERR, err)
			return
		}

		log.Log("state=success")
	})
}
func (p *program) run() error {
	// Allow the main thread to finish
	// This prevents the service from being terminated
	runtime.Gosched()

	p.init()

	ticker := time.Tick(3 * time.Hour)

	for {
		logger.Info("Fetching new results")
		if err := p.client.Run(); err != nil {
			logger.Error(err)
			rollbar.Error(rollbar.ERR, err)
		}
		if p.client.Changed() {
			logger.Info("New results detected. Sending email...")
			p.SendMail()
		}
		logger.Info("Going back to sleep")
		// Sleep until the next update time
		select {
		case <-ticker:
		}
	}

	return nil
}
Esempio n. 5
0
func main() {
	app := cli.NewApp()
	app.Name = "Scalingo Client"
	app.Author = "Scalingo Team"
	app.Email = "*****@*****.**"
	app.Usage = "Manage your apps and containers"
	app.Version = config.Version
	app.CategorizedHelp = true
	app.Flags = []cli.Flag{
		cli.StringFlag{Name: "app, a", Value: "<name>", Usage: "Name of the app", EnvVar: "SCALINGO_APP"},
		cli.StringFlag{Name: "remote, r", Value: "scalingo", Usage: "Name of the remote", EnvVar: ""},
	}
	app.EnableBashCompletion = true
	app.BashComplete = func(c *cli.Context) {
		ScalingoAppComplete(c)
	}
	app.Action = DefaultAction

	// Commands
	for _, command := range cmd.Commands {
		oldFunc := command.BashComplete
		command.BashComplete = func(c *cli.Context) {
			n := len(os.Args) - 2
			if n > 0 && !autocomplete.FlagsAutoComplete(c, os.Args[n]) && oldFunc != nil {
				oldFunc(c)
			}
		}
		app.Commands = append(app.Commands, command)
	}

	go signals.Handle()

	bashComplete := false
	for i := range os.Args {
		if strings.Contains(os.Args[i], "generate-bash-completion") {
			bashComplete = true
		}
	}

	if !bashComplete {
		if len(os.Args) >= 2 && os.Args[1] == cmd.UpdateCommand.Name {
			err := update.Check()
			if err != nil {
				rollbar.Error(rollbar.ERR, err)
			}
			return
		} else {
			defer update.Check()
		}
	} else {
		// If we are completing stuff, disable logging
		config.C.DisableInteractive = true
	}

	if err := app.Run(os.Args); err != nil {
		fmt.Println("Fail to run scalingo", err)
	}
}
Esempio n. 6
0
func handlePanic() {
	if rec := recover(); rec != nil {
		err, ok := rec.(error)
		if !ok {
			err = errors.New(rec.(string))
		}
		Errln("ERROR:", err)
		if Channel == "?" {
			debug.PrintStack()
		} else {
			rollbar.Error(rollbar.ERR, err, rollbarFields()...)
			rollbar.Wait()
		}
		Exit(1)
	}
}
Esempio n. 7
0
func Error(log *logger.Logger, err error) {
	if log != nil {
		log.Error(err)
	}

	if rollbar.Token != "" {
		extraData := map[string]string{
			"AWS_REGION": os.Getenv("AWS_REGION"),
			"RACK":       os.Getenv("RACK"),
			"RELEASE":    os.Getenv("RELEASE"),
			"VPC":        os.Getenv("VPC"),
		}
		extraField := &rollbar.Field{"env", extraData}
		rollbar.Error(rollbar.ERR, err, extraField)
	}
}
Esempio n. 8
0
func ReportCriticalVerbose(err error, message string, fields map[string]string) {
	fields["message"] = message
	rollbarFields := mapToRollbarFields(fields)
	rollbar.Error("critical", err, rollbarFields...)
}
func (p *program) SendMail() {

	win := p.client.CheckWin(config.Config.Target)
	templateVars := map[string]string{}

	message := &mandrill.Message{}
	if win {
		message.Subject = "WIN --- Postcode Lottery"
	} else {
		message.Subject = "Postcode Lottery"
	}
	message.InlineCSS = true
	message.Subaccount = "fpl"

	message.FromEmail = config.Config.Services.Mandrill.Sender.Email
	message.FromName = config.Config.Services.Mandrill.Sender.Name

	message.AddRecipient(config.Config.Target, config.Config.Target, "to")

	if p.daily.Changed() {

		att := &mandrill.Attachment{
			Type:    "image/png",
			Name:    "daily",
			Content: p.daily.GetEncodedImage(),
		}
		templateVars["daily"] = "CHANGED"
		message.Attachments = make([]*mandrill.Attachment, 1)
		message.Attachments[0] = att
	}

	// Global vars

	if p.stockpot.Changed() {
		templateVars["stockpot"] = strings.Join(p.stockpot.GetPostcodes(), "<br>")
	}
	if p.survey.Changed() {
		templateVars["survey"] = p.survey.GetPostcode()
	}
	message.GlobalMergeVars = mandrill.MapToVars(templateVars)

	templateContent := map[string]string{}
	responses, err := p.mailer.MessagesSendTemplate(message, "fpl", templateContent)

	if err != nil {
		rollbar.Error(rollbar.ERR, err)
		if config.Config.Debug {
			logger.Error(err)
		}
	}

	for _, response := range responses {
		if strings.EqualFold(response.Status, "rejected") || strings.EqualFold(response.Status, "invalid") {
			apiErrorField := &rollbar.Field{Name: "Response", Data: response}
			rollbar.Error(rollbar.ERR, fmt.Errorf("Email send failed"), apiErrorField)
			if config.Config.Debug {
				logger.Error(response)
			}
		}

	}
}