func pullCommand(c *cli.Context) { args := c.Args() if len(args) < 1 { log.Fatal("rocker pull <image>") } dockerClient, err := dockerclient.NewFromCli(c) if err != nil { log.Fatal(err) } cacheDir, err := util.MakeAbsolute(c.String("cache-dir")) if err != nil { log.Fatal(err) } options := build.DockerClientOptions{ Client: dockerClient, Auth: initAuth(c), Log: log.StandardLogger(), S3storage: s3.New(dockerClient, cacheDir), StdoutContainerFormatter: log.StandardLogger().Formatter, StderrContainerFormatter: log.StandardLogger().Formatter, } client := build.NewDockerClient(options) if err := client.PullImage(args[0]); err != nil { log.Fatal(err) } }
func main() { flag.Parse() // connect with the logging server if logger != "" && (amroot || debug) { // blocks until we can connect to the logger lh, err := logutils.NewLoggerHook(logger, hostname, app) if err != nil { log.WithFields(log.Fields{ "file": logutils.File(), }).Fatalln("ERROR SETTING UP LOGGING SERVER:", err) } log.AddHook(lh) } //log.Println("IN FORKEXEC") ////log.SetOutput(ioutil.Discard) ////log.Println("Log Test") ////fmt.Println("exiting logger block") //} // log.Println("IN FORK EXEC") // recombine the flags for exec to use args := []string{ "-failures=" + strconv.Itoa(failures), "-rfail=" + strconv.Itoa(rFail), "-ffail=" + strconv.Itoa(fFail), "-hostname=" + hostname, "-config=" + configFile, "-logger=" + logger, "-app=" + app, "-pprof=" + pprofaddr, "-physaddr=" + physaddr, "-rootwait=" + strconv.Itoa(rootwait), "-debug=" + strconv.FormatBool(debug), "-rounds=" + strconv.Itoa(rounds), "-amroot=" + strconv.FormatBool(amroot), "-test_connect=" + strconv.FormatBool(testConnect), "-suite=" + suite, } cmd := exec.Command("./exec", args...) cmd.Stdout = log.StandardLogger().Writer() cmd.Stderr = log.StandardLogger().Writer() // log.Println("running command:", cmd) err := cmd.Run() if err != nil { log.Errorln("cmd run:", err) } // get CPU usage stats st := cmd.ProcessState.SystemTime() ut := cmd.ProcessState.UserTime() log.WithFields(log.Fields{ "file": logutils.File(), "type": "forkexec", "systime": st, "usertime": ut, }).Info("") }
func CmdImport(databaseName, filePath, mongoCollection, mongoDatabase string, id IDb, is services.IServices, ij jobs.IJobs) error { if _, err := os.Stat(filePath); os.IsNotExist(err) { return fmt.Errorf("A file does not exist at path '%s'", filePath) } service, err := is.RetrieveByLabel(databaseName) if err != nil { return err } if service == nil { return fmt.Errorf("Could not find a service with the label \"%s\". You can list services with the \"catalyze services\" command.", databaseName) } logrus.Printf("Backing up \"%s\" before performing the import", databaseName) job, err := id.Backup(service) if err != nil { return err } logrus.Printf("Backup started (job ID = %s)", job.ID) // all because logrus treats print, println, and printf the same logrus.StandardLogger().Out.Write([]byte("Polling until backup finishes.")) status, err := ij.PollTillFinished(job.ID, service.ID) if err != nil { return err } job.Status = status logrus.Printf("\nEnded in status '%s'", job.Status) err = id.DumpLogs("backup", job, service) if err != nil { return err } if job.Status != "finished" { return fmt.Errorf("Job finished with invalid status %s", job.Status) } logrus.Printf("Importing '%s' into %s (ID = %s)", filePath, databaseName, service.ID) job, err = id.Import(filePath, mongoCollection, mongoDatabase, service) if err != nil { return err } // all because logrus treats print, println, and printf the same logrus.StandardLogger().Out.Write([]byte(fmt.Sprintf("Processing import (job ID = %s).", job.ID))) status, err = ij.PollTillFinished(job.ID, service.ID) if err != nil { return err } job.Status = status logrus.Printf("\nImport complete (end status = '%s')", job.Status) err = id.DumpLogs("restore", job, service) if err != nil { return err } if job.Status != "finished" { return fmt.Errorf("Finished with invalid status %s", job.Status) } return nil }
func init() { flag.Usage = func() { fmt.Fprint(os.Stderr, fmt.Sprintf(banner, version, os.Args[0])) flag.PrintDefaults() } flag.BoolVar(&movie, "movie", false, "parse as movie file") flag.BoolVar(&tv, "tv", false, "parse as TV file") flag.BoolVar(&showVersion, "showVersion", false, "show showVersion and exit") flag.StringVar(&format, "format", "", "output format") flag.Parse() filenames = flag.Args() // Set debug level if debug { log.StandardLogger().Level = log.DebugLevel } else { log.StandardLogger().Level = log.ErrorLevel } if movie && tv { fmt.Fprintln(os.Stderr, "Cannot use both -movie and -tv simultaneously") flag.Usage() os.Exit(1) } if !movie && !tv { fmt.Fprintln(os.Stderr, "Please provide -movie or -tv") flag.Usage() os.Exit(1) } if showVersion { fmt.Println(version) os.Exit(0) } if len(filenames) == 0 { fmt.Fprintln(os.Stderr, "No input provided") flag.Usage() os.Exit(1) } // Set default format if -format is omitted if strings.Trim(format, " ") == "" { if movie { format = "{{spaces .Title | title | underscores}}.{{.Year}}.{{.Ext}}" } else { format = `{{spaces .Title | title | underscores}}.{{printf "%02d" .Season}}{{printf "%02d" .Episode}}.{{.Ext}}` } } }
func (m *mod) Start() error { stdOut := log.StandardLogger().Writer() stdErr := log.StandardLogger().Writer() r := mux.NewRouter() r.Handle("/r/module/instances", handlers.LoggingHandler(stdOut, http.HandlerFunc(moduleInstHandler))) r.Handle("/r/module/instances/{id}/start", handlers.LoggingHandler(stdOut, http.HandlerFunc(moduleInstStartHandler))) r.Handle("/r/module/types", handlers.LoggingHandler(stdOut, http.HandlerFunc(moduleTypeHandler))) r.Handle("/images/rexray-banner-logo.svg", handlers.LoggingHandler(stdOut, http.HandlerFunc(imagesHandler))) r.Handle("/scripts/jquery-1.11.3.min.js", handlers.LoggingHandler(stdOut, http.HandlerFunc(scriptsHandler))) r.Handle("/styles/main.css", handlers.LoggingHandler(stdOut, http.HandlerFunc(stylesHandler))) r.Handle("/", handlers.LoggingHandler(stdOut, http.HandlerFunc(indexHandler))) _, addr, parseAddrErr := util.ParseAddress(m.Address()) if parseAddrErr != nil { return parseAddrErr } s := &http.Server{ Addr: addr, Handler: r, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, ErrorLog: golog.New(stdErr, "", 0), } go func() { defer stdOut.Close() defer stdErr.Close() sErr := s.ListenAndServe() if sErr != nil { panic(sErr) } }() return nil }
func TestLogrusWithJsonFormatter(t *testing.T) { p := &Person{ Name: "Bruce", Alias: "Batman", Hideout: &Hideout{ Name: "JLU Tower", DimensionId: 52, }, } log.SetFormatter(newJsonFormatter()) entry := log.NewEntry(log.StandardLogger()) entry.Message = "the dark knight" entry.Data = log.Fields{"hero": p} s, _ := entry.String() if !strings.Contains(s, `"hero.name":"Bruce"`) { t.Fatalf(`missing "hero.name":"Bruce"`) } if !strings.Contains(s, `"hero.alias":"Batman"`) { t.Fatalf(`missing "hero.alias":"Batman"`) } if !strings.Contains(s, `"hero.hideout.name":"JLU Tower"`) { t.Fatalf(`missing "hero.hideout.name":"JLU Tower"`) } if !strings.Contains(s, `"hero.hideout.dimensionId":52`) { t.Fatalf(`missing "hero.hideout.dimensionId":52`) } }
// Validate validates the provided data (d) against the provided schema (s). func Validate(ctx types.Context, s, d []byte) error { if ctx == nil { log.StandardLogger().WithFields(log.Fields{ "schema": string(s), "body": string(d), }).Debug("validating schema") } else { ctx.WithFields(log.Fields{ "schema": string(s), "body": string(d), }).Debug("validating schema") } validator, err := getSchemaValidator(s) if err != nil { return err } if len(d) == 0 { d = []byte("{}") } data, err := ucl.Parse(bytes.NewReader(d)) if err != nil { return err } return validator.Validate(data) }
// NewFeedWatcher returns a new FeedWatcher instance. func NewFeedWatcher( feedInfo db.FeedInfo, crawlChan chan *FeedCrawlRequest, responseChan chan *FeedCrawlResponse, mailChan chan *mail.Request, dbh db.Service, GUIDCache []string, minSleep int64, maxSleep int64, ) *FeedWatcher { guids := map[string]bool{} for _, i := range GUIDCache { guids[i] = true } return &FeedWatcher{ FeedInfo: feedInfo, exitChan: make(chan int), crawlChan: crawlChan, responseChan: responseChan, mailerChan: mailChan, polling: false, crawling: false, minSleepTime: time.Duration(minSleep) * time.Second, maxSleepTime: time.Duration(maxSleep) * time.Second, dbh: dbh, GUIDCache: guids, LastCrawlResponse: &FeedCrawlResponse{}, After: After, Logger: logrus.StandardLogger(), } }
func CmdBackup(databaseName string, skipPoll bool, id IDb, is services.IServices, ij jobs.IJobs) error { service, err := is.RetrieveByLabel(databaseName) if err != nil { return err } if service == nil { return fmt.Errorf("Could not find a service with the label \"%s\". You can list services with the \"catalyze services\" command.", databaseName) } job, err := id.Backup(service) if err != nil { return err } logrus.Printf("Backup started (job ID = %s)", job.ID) if !skipPoll { // all because logrus treats print, println, and printf the same logrus.StandardLogger().Out.Write([]byte("Polling until backup finishes.")) status, err := ij.PollTillFinished(job.ID, service.ID) if err != nil { return err } job.Status = status logrus.Printf("\nEnded in status '%s'", job.Status) err = id.DumpLogs("backup", job, service) if err != nil { return err } if job.Status != "finished" { return fmt.Errorf("Job finished with invalid status %s", job.Status) } } logrus.Printf("You can download your backup with the \"catalyze db download %s %s ./output_file_path\" command", databaseName, job.ID) return nil }
func configureSyslog(syslogParam string) { var err error var hook log.Hook // disable colors if we're writing to syslog *and* we're the default text // formatter, because the tty detection is useless here. if tf, ok := log.StandardLogger().Formatter.(*log.TextFormatter); ok { tf.DisableColors = true } if syslogParam == "kernel" { hook, err = logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, "netplugin") if err != nil { log.Fatalf("Could not connect to kernel syslog") } } else { u, err := url.Parse(syslogParam) if err != nil { log.Fatalf("Could not parse syslog spec: %v", err) } hook, err = logrus_syslog.NewSyslogHook(u.Scheme, u.Host, syslog.LOG_INFO, "netplugin") if err != nil { log.Fatalf("Could not connect to syslog: %v", err) } } log.AddHook(hook) }
func CmdList(is ISites, iservices services.IServices) error { serviceProxy, err := iservices.RetrieveByLabel("service_proxy") if err != nil { return err } sites, err := is.List(serviceProxy.ID) if err != nil { return err } if sites == nil || len(*sites) == 0 { logrus.Println("No sites found") return nil } svcs, err := iservices.List() svcMap := map[string]string{} for _, s := range *svcs { svcMap[s.ID] = s.Label } data := [][]string{{"NAME", "CERT", "UPSTREAM SERVICE"}} for _, s := range *sites { data = append(data, []string{s.Name, s.Cert, svcMap[s.UpstreamService]}) } table := tablewriter.NewWriter(logrus.StandardLogger().Out) table.SetBorder(false) table.SetRowLine(false) table.SetCenterSeparator("") table.SetColumnSeparator("") table.SetRowSeparator("") table.AppendBulk(data) table.Render() return nil }
func main() { envflag.Parse() if *debug { logrus.SetLevel(logrus.DebugLevel) } else { logrus.SetLevel(logrus.WarnLevel) } handler := router.Load( ginrus.Ginrus(logrus.StandardLogger(), time.RFC3339, true), middleware.Version, middleware.Store(), middleware.Remote(), middleware.Cache(), ) if *cert != "" { logrus.Fatal( http.ListenAndServeTLS(*addr, *cert, *key, handler), ) } else { logrus.Fatal( http.ListenAndServe(*addr, handler), ) } }
func init() { // 初始化日志 logrus.SetFormatter(&logrus.JSONFormatter{}) log.SetOutput(logrus.StandardLogger().Out) // 初始化配置 Config = loadConfig() lv, err := logrus.ParseLevel(Config.LogLevel) if err != nil { logrus.WithError(err).Warn("解析日志等级出错") lv = logrus.DebugLevel } logrus.SetLevel(lv) if Config.ReportOn { hook, err := logrus_mail.NewMailAuthHook(Config.AppName, Config.MailerHost, Config.MailerPort, Config.MailerUser, Config.MailReceiver, Config.MailerUser, Config.MailerPass) if err == nil { logrus.AddHook(hook) } } exeRoot := filepath.Dir(os.Args[0]) f, err := os.OpenFile(filepath.Join(exeRoot, "retask.log"), os.O_APPEND|os.O_CREATE, os.ModePerm) if err != nil { logrus.WithError(err).Fatal("打开日志文件失败") } logrus.SetOutput(f) }
func runServer(neoURL string, port string, cacheDuration string, env string) { if duration, durationErr := time.ParseDuration(cacheDuration); durationErr != nil { log.Fatalf("Failed to parse cache duration string, %v", durationErr) } else { organisations.CacheControlHeader = fmt.Sprintf("max-age=%s, public", strconv.FormatFloat(duration.Seconds(), 'f', 0, 64)) } conf := neoutils.ConnectionConfig{ BatchSize: 1024, Transactional: false, HTTPClient: &http.Client{ Transport: &http.Transport{ MaxIdleConnsPerHost: 100, }, Timeout: 1 * time.Minute, }, BackgroundConnect: true, } db, err := neoutils.Connect(neoURL, &conf) if err != nil { log.Fatalf("Error connecting to neo4j %s", err) } organisations.OrganisationDriver = organisations.NewCypherDriver(db, env) servicesRouter := mux.NewRouter() // Healthchecks and standards first servicesRouter.HandleFunc("/__health", v1a.Handler("PublicOrganisationsRead Healthchecks", "Checks for accessing neo4j", organisations.HealthCheck())) servicesRouter.HandleFunc("/__gtg", organisations.GoodToGo) // Then API specific ones: servicesRouter.HandleFunc("/organisations/{uuid}", organisations.GetOrganisation).Methods("GET") servicesRouter.HandleFunc("/organisations/{uuid}", organisations.MethodNotAllowedHandler) var monitoringRouter http.Handler = servicesRouter monitoringRouter = httphandlers.TransactionAwareRequestLoggingHandler(log.StandardLogger(), monitoringRouter) monitoringRouter = httphandlers.HTTPMetricsHandler(metrics.DefaultRegistry, monitoringRouter) // The following endpoints should not be monitored or logged (varnish calls one of these every second, depending on config) // The top one of these build info endpoints feels more correct, but the lower one matches what we have in Dropwizard, // so it's what apps expect currently same as ping, the content of build-info needs more definition //using http router here to be able to catch "/" http.HandleFunc(status.PingPath, status.PingHandler) http.HandleFunc(status.PingPathDW, status.PingHandler) http.HandleFunc(status.BuildInfoPath, status.BuildInfoHandler) http.HandleFunc(status.BuildInfoPathDW, status.BuildInfoHandler) http.HandleFunc("/__gtg", organisations.GoodToGo) http.Handle("/", monitoringRouter) if err := http.ListenAndServe(":"+port, nil); err != nil { log.Fatalf("Unable to start server: %v", err) } }
func main() { flag.Parse() ch, err := tchannel.NewChannel("ping", nil) if err != nil { log.Fatalf("channel did not create successfully: %v", err) } logger := log.StandardLogger() worker := &worker{ channel: ch, ringpop: ringpop.NewRingpop("ping-app", *hostport, ch, &ringpop.Options{ Logger: bark.NewLoggerFromLogrus(logger), }), logger: logger, } if err := worker.RegisterPong(); err != nil { log.Fatalf("could not register pong handler: %v", err) } if err := worker.channel.ListenAndServe(*hostport); err != nil { log.Fatalf("could not listen on given hostport: %v", err) } opts := new(ringpop.BootstrapOptions) opts.File = *hostfile if _, err := worker.ringpop.Bootstrap(opts); err != nil { log.Fatalf("ringpop bootstrap failed: %v", err) } select {} }
// NewDockerClient makes a new client that works with a docker socket func NewDockerClient(options DockerClientOptions) *DockerClient { log := options.Log if log == nil { log = logrus.StandardLogger() } u, err := url.Parse(options.Host) if err != nil { log.Errorf("Wrong host, can't parse: '%s'", options.Host) } isUnixSocket := ("unix" == u.Scheme) unixSockPath := u.Path return &DockerClient{ client: options.Client, auth: options.Auth, log: log, s3storage: options.S3storage, stdoutContainerFormatter: options.StdoutContainerFormatter, stderrContainerFormatter: options.StderrContainerFormatter, pushRetryCount: options.PushRetryCount, isUnixSocket: isUnixSocket, unixSockPath: unixSockPath, useHumanSize: !options.LogExactSizes, } }
func RunServerWithConf(conf RWConf) { for path, service := range conf.Services { err := service.Initialise() if err != nil { log.Fatalf("Service for path %s could not startup, err=%s", path, err) } } if conf.Env != "local" { f, err := os.OpenFile("/var/log/apps/"+conf.ServiceName+"-go-app.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644) if err == nil { log.SetOutput(f) log.SetFormatter(&log.TextFormatter{DisableColors: true}) } else { log.Fatalf("Failed to initialise log file, %v", err) } defer f.Close() } var m http.Handler m = router(conf.Services, conf.HealthHandler) if conf.EnableReqLog { m = httphandlers.TransactionAwareRequestLoggingHandler(log.StandardLogger(), m) } m = httphandlers.HTTPMetricsHandler(metrics.DefaultRegistry, m) http.Handle("/", m) log.Printf("listening on %d", conf.Port) log.Println(http.ListenAndServe(fmt.Sprintf(":%d", conf.Port), nil).Error()) log.Printf("exiting on %s", conf.ServiceName) }
func NewLogrusLogger(ctx *cli.Context) Logger { logFile := ctx.GlobalString("log-file") if logFile != "" { if err := os.MkdirAll(path.Dir(logFile), 0755); err != nil { logrus.Errorf("Failed to create path %s: %s", path.Dir(logFile), err.Error()) } else { file, err := os.OpenFile(logFile, syscall.O_CREAT|syscall.O_APPEND|syscall.O_WRONLY, 0644) if err != nil { logrus.Errorf("Failed to open log file %s: %s", logFile, err.Error()) } else { logrus.SetOutput(file) } } } switch ctx.GlobalString("log-format") { case "json": logrus.SetFormatter(&logrus.JSONFormatter{}) case "logstash": logrus.SetFormatter(&logstash.LogstashFormatter{}) default: logrus.SetFormatter(&logrus.TextFormatter{}) } if ctx.GlobalBool("debug") { logrus.SetLevel(logrus.DebugLevel) } return &logrusLogger{ logger: logrus.StandardLogger(), } }
func CmdShow(name string, is ISites, iservices services.IServices) error { serviceProxy, err := iservices.RetrieveByLabel("service_proxy") if err != nil { return err } sites, err := is.List(serviceProxy.ID) if err != nil { return err } var site *models.Site for _, s := range *sites { if s.Name == name { site = &s break } } if site == nil { return fmt.Errorf("Could not find a site with the label \"%s\". You can list sites with the \"catalyze sites list\" command.", name) } site, err = is.Retrieve(site.ID, serviceProxy.ID) if err != nil { return err } table, err := simpletable.New(simpletable.HeadersForType(models.Site{}), []models.Site{*site}) if err != nil { return err } table.Write(logrus.StandardLogger().Out) return nil }
func main() { flag.Usage = func() { fmt.Println("Usage: quilt " + "[-log-level=<level> | -l=<level>] [-H=<listen_address>] " + "[log-file=<log_output_file>] " + "[daemon | inspect <stitch> | run <stitch> | minion | " + "stop <namespace> | get <import_path> | " + "machines | containers | ssh <machine> | " + "exec <container> <command> | " + "logs <container>]") fmt.Println("\nWhen provided a stitch, quilt takes responsibility\n" + "for deploying it as specified. Alternatively, quilt may be\n" + "instructed to stop all deployments in a given namespace,\n" + "or the default namespace if none is provided.\n") flag.PrintDefaults() fmt.Println(" Valid logger levels are:\n" + " debug, info, warn, error, fatal or panic.") } var logOut = flag.String("log-file", "", "log output file (will be overwritten)") var logLevel = flag.String("log-level", "info", "level to set logger to") flag.StringVar(logLevel, "l", "info", "level to set logger to") flag.Parse() level, err := parseLogLevel(*logLevel) if err != nil { fmt.Println(err) usage() } log.SetLevel(level) log.SetFormatter(util.Formatter{}) if *logOut != "" { file, err := os.Create(*logOut) if err != nil { fmt.Printf("Failed to create file %s\n", *logOut) os.Exit(1) } defer file.Close() log.SetOutput(file) } // GRPC spews a lot of useless log messages so we tell to eat its logs, unless // we are in debug mode grpclog.SetLogger(l_mod.New(ioutil.Discard, "", 0)) if level == log.DebugLevel { grpclog.SetLogger(log.StandardLogger()) } if len(flag.Args()) == 0 { usage() } subcommand := flag.Arg(0) if quiltctl.HasSubcommand(subcommand) { quiltctl.Run(subcommand, flag.Args()[1:]) } else { usage() } }
// GetLogrusLogger returns the logrus logger for the context. If one more keys // are provided, they will be resolved on the context and included in the // logger. Only use this function if specific logrus functionality is // required. func getLogrusLogger(ctx Context, keys ...interface{}) *logrus.Entry { var logger *logrus.Entry // Get a logger, if it is present. loggerInterface := ctx.Value("logger") if loggerInterface != nil { if lgr, ok := loggerInterface.(*logrus.Entry); ok { logger = lgr } } if logger == nil { // If no logger is found, just return the standard logger. logger = logrus.NewEntry(logrus.StandardLogger()) } fields := logrus.Fields{} for _, key := range keys { v := ctx.Value(key) if v != nil { fields[fmt.Sprint(key)] = v } } return logger.WithFields(fields) }
func main() { log := logrus.StandardLogger() configFileName := flag.String("c", "", "path to the configuration file") flag.Parse() if *configFileName == "" { log.Fatal("no configuration file specified") } configData, err := ioutil.ReadFile(*configFileName) if err != nil { log.Fatal("error reading configuration file: ", err.Error()) } config, err := server.NewConfigFromYAML(configData) if err != nil { log.Fatal("error parsing configuration file: ", err.Error()) } s, err := server.NewServer(log, config) if err != nil { log.Fatal(err.Error()) } if err := s.ListenAndServe(); err != nil { log.Fatal(err.Error()) } }
// we'll connect to the database through this function func Init() { dbMutex.Lock() defer dbMutex.Unlock() if initialized { return } DBUrl = url.URL{ Scheme: "postgres", Host: config.Constants.DbAddr, Path: config.Constants.DbDatabase, RawQuery: "sslmode=disable", } logrus.Info("Connecting to DB on %s", DBUrl.String()) DBUrl.User = url.UserPassword(config.Constants.DbUsername, config.Constants.DbPassword) var err error DB, err = gorm.Open("postgres", DBUrl.String()) // DB, err := gorm.Open("sqlite3", "/tmp/gorm.db") if err != nil { logrus.Fatal(err.Error()) } DB.SetLogger(logrus.StandardLogger()) logrus.Info("Connected!") initialized = true }
// Draw the square. // Remember that the square should be ordered previously to make sure it // prints in the intended order. Take a look at // `github.com/Willyfrog/peano/matrix.Strategy` Interface func (sq *Square) Draw(canvas *drawing.Canvas) { path := canvas.GetContext() if log.StandardLogger().Level == log.DebugLevel { if sq.X == 0 && sq.Y == 0 { path.SetStrokeColor(color.RGBA{0x44, 0xff, 0x44, 0xff}) } else if sq.X == 0 && sq.Y == 1 { path.SetStrokeColor(color.RGBA{0xff, 0x44, 0x44, 0xff}) } else { path.SetStrokeColor(color.RGBA{0xcc, 0xcc, 0xcc, 0xff}) } } else { path.SetStrokeColor(color.RGBA{0xcc, 0xcc, 0xcc, 0xff}) } path.SetLineWidth(1) xo, yo := sq.Origin() xe, ye := sq.End() drawing.DrawSquare(xo, yo, xe, ye, path) path.Stroke() //path.FillStroke() //log.Debug(fmt.Sprintf("Result: %v", sq.Points)) var origin *point.Point for _, pt := range sq.Points { pt.Draw(canvas) if origin != nil { linepath := canvas.GetContext() path.SetStrokeColor(color.RGBA{0x44, 0x44, 0x88, 0xff}) path.SetLineWidth(5) drawing.DrawLine(origin.X, origin.Y, pt.X, pt.Y, linepath) linepath.Stroke() } origin = pt } }
// GetLogrusLogger returns the logrus logger for the context. If one more keys // are provided, they will be resolved on the context and included in the // logger. Only use this function if specific logrus functionality is // required. func getLogrusLogger(ctx Context, keys ...interface{}) *logrus.Entry { var logger *logrus.Entry // Get a logger, if it is present. loggerInterface := ctx.Value("logger") if loggerInterface != nil { if lgr, ok := loggerInterface.(*logrus.Entry); ok { logger = lgr } } if logger == nil { fields := logrus.Fields{} // Fill in the instance id, if we have it. instanceID := ctx.Value("instance.id") if instanceID != nil { fields["instance.id"] = instanceID } fields["go.version"] = runtime.Version() // If no logger is found, just return the standard logger. logger = logrus.StandardLogger().WithFields(fields) } fields := logrus.Fields{} for _, key := range keys { v := ctx.Value(key) if v != nil { fields[fmt.Sprint(key)] = v } } return logger.WithFields(fields) }
func initLogs(ctx *cli.Context) { logger := log.StandardLogger() if ctx.GlobalBool("verbose") { logger.Level = log.DebugLevel } var ( isTerm = log.IsTerminal() json = ctx.GlobalBool("json") useColors = isTerm && !json ) if ctx.GlobalIsSet("colors") { useColors = ctx.GlobalBool("colors") } color.NoColor = !useColors if json { logger.Formatter = &log.JSONFormatter{} } else { formatter := &textformatter.TextFormatter{} formatter.DisableColors = !useColors logger.Formatter = formatter } }
func (d *driver) serfInit() error { var err error config := serf.DefaultConfig() config.Init() config.MemberlistConfig.BindAddr = d.bindAddress d.eventCh = make(chan serf.Event, 4) config.EventCh = d.eventCh config.UserCoalescePeriod = 1 * time.Second config.UserQuiescentPeriod = 50 * time.Millisecond config.LogOutput = logrus.StandardLogger().Out s, err := serf.Create(config) if err != nil { return fmt.Errorf("failed to create cluster node: %v", err) } defer func() { if err != nil { s.Shutdown() } }() d.serfInstance = s d.notifyCh = make(chan ovNotify) d.exitCh = make(chan chan struct{}) go d.startSerfLoop(d.eventCh, d.notifyCh, d.exitCh) return nil }
// NewContainerFormatter returns an object that is given to logrus to better format // contaienr output func NewContainerFormatter(container *Container, level log.Level) log.Formatter { return &formatter{ container: container, level: level, delegate: log.StandardLogger().Formatter, } }
func main() { r := gin.New() // Add a ginrus middleware, which: // - Logs all requests, like a combined access and error log. // - Logs to stdout. // - RFC3339 with UTC time format. r.Use(ginrus.Ginrus(logrus.StandardLogger(), time.RFC3339, true)) // Add similar middleware, but: // - Only logs requests with errors, like an error log. // - Logs to stderr instead of stdout. // - Local time zone instead of UTC. logger := logrus.New() logger.Level = logrus.ErrorLevel logger.Out = os.Stderr r.Use(ginrus.Ginrus(logger, time.RFC3339, false)) // Example ping request. r.GET("/ping", func(c *gin.Context) { c.String(200, "pong "+fmt.Sprint(time.Now().Unix())) }) // Listen and Server in 0.0.0.0:8080 r.Run(":8080") }
func (c *client) logResponse(res *http.Response) { if !c.logResponses { return } w := log.StandardLogger().Writer() fmt.Fprintln(w) fmt.Fprint(w, " -------------------------- ") fmt.Fprint(w, "HTTP RESPONSE (CLIENT)") fmt.Fprintln(w, " -------------------------") buf, err := httputil.DumpResponse( res, res.Header.Get("Content-Type") != "application/octet-stream") if err != nil { return } bw := &bytes.Buffer{} gotil.WriteIndented(bw, buf) scanner := bufio.NewScanner(bw) for { if !scanner.Scan() { break } fmt.Fprintln(w, scanner.Text()) } }