func (cmd *ATCCommand) constructLogger() (lager.Logger, *lager.ReconfigurableSink) { logger := lager.NewLogger("atc") logLevel := lager.INFO if cmd.Developer.DevelopmentMode { logLevel = lager.DEBUG } reconfigurableSink := lager.NewReconfigurableSink(lager.NewWriterSink(os.Stdout, lager.DEBUG), logLevel) logger.RegisterSink(reconfigurableSink) if cmd.Metrics.YellerAPIKey != "" { yellerSink := zest.NewYellerSink(cmd.Metrics.YellerAPIKey, cmd.Metrics.YellerEnvironment) logger.RegisterSink(yellerSink) } return logger, reconfigurableSink }
func configureLogger() lager.Logger { var lagerLogLevel lager.LogLevel switch *logLevel { case "debug": lagerLogLevel = lager.DEBUG case "info": lagerLogLevel = lager.INFO case "error": lagerLogLevel = lager.ERROR case "fatal": lagerLogLevel = lager.FATAL default: panic(fmt.Errorf("unknown log level: %s", logLevel)) } logger := lager.NewLogger("delphos") sink := lager.NewReconfigurableSink(lager.NewWriterSink(os.Stdout, lager.DEBUG), lagerLogLevel) logger.RegisterSink(sink) return logger }
func InitializeLogger(minLogLevel LogLevel) (lager.Logger, *lager.ReconfigurableSink, error) { var minLagerLogLevel lager.LogLevel switch minLogLevel { case LogLevelDebug: minLagerLogLevel = lager.DEBUG case LogLevelInfo: minLagerLogLevel = lager.INFO case LogLevelError: minLagerLogLevel = lager.ERROR case LogLevelFatal: minLagerLogLevel = lager.FATAL default: return nil, nil, fmt.Errorf("unknown log level: %s", minLogLevel) } logger := lager.NewLogger("garagepi") sink := lager.NewReconfigurableSink(lager.NewWriterSink(os.Stdout, lager.DEBUG), minLagerLogLevel) logger.RegisterSink(sink) return logger, sink, nil }
func New(component string) (lager.Logger, *lager.ReconfigurableSink) { var minLagerLogLevel lager.LogLevel switch minLogLevel { case DEBUG: minLagerLogLevel = lager.DEBUG case INFO: minLagerLogLevel = lager.INFO case ERROR: minLagerLogLevel = lager.ERROR case FATAL: minLagerLogLevel = lager.FATAL default: panic(fmt.Errorf("unknown log level: %s", minLogLevel)) } logger := lager.NewLogger(component) sink := lager.NewReconfigurableSink(lager.NewWriterSink(os.Stdout, lager.DEBUG), minLagerLogLevel) logger.RegisterSink(sink) return logger, sink }
fakeEngine = new(enginefakes.FakeEngine) fakeWorkerClient = new(workerfakes.FakeClient) fakeSchedulerFactory = new(jobserverfakes.FakeSchedulerFactory) var err error cliDownloadsDir, err = ioutil.TempDir("", "cli-downloads") Expect(err).NotTo(HaveOccurred()) constructedEventHandler = &fakeEventHandlerFactory{} logger := lagertest.NewTestLogger("callbacks") sink = lager.NewReconfigurableSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG), lager.DEBUG) logger.RegisterSink(sink) handler, err := api.NewHandler( logger, externalURL, wrappa.NewAPIAuthWrappa(true, authValidator, userContextReader), fakeTokenGenerator, providerFactory, oAuthBaseURL, pipelineDBFactory, configDB,
. "github.com/onsi/ginkgo" . "github.com/onsi/gomega" "github.com/onsi/gomega/gbytes" ) var _ = Describe("ReconfigurableSink", func() { var ( testSink *lagertest.TestSink sink *lager.ReconfigurableSink ) BeforeEach(func() { testSink = lagertest.NewTestSink() sink = lager.NewReconfigurableSink(testSink, lager.INFO) }) It("returns the current level", func() { Expect(sink.GetMinLevel()).To(Equal(lager.INFO)) }) Context("when logging above the minimum log level", func() { BeforeEach(func() { sink.Log(lager.INFO, []byte("hello world")) }) It("writes to the given sink", func() { Expect(testSink.Buffer()).To(gbytes.Say("hello world\n")) }) })
"github.com/onsi/gomega/gbytes" ) var _ = Describe("CF Debug Server", func() { var ( logBuf *gbytes.Buffer sink *lager.ReconfigurableSink process ifrit.Process ) BeforeEach(func() { logBuf = gbytes.NewBuffer() sink = lager.NewReconfigurableSink( lager.NewWriterSink(logBuf, lager.DEBUG), // permit no logging by default, for log reconfiguration below lager.FATAL+1, ) }) AfterEach(func() { ginkgomon.Interrupt(process) }) Describe("AddFlags", func() { It("adds flags to the flagset", func() { flags := flag.NewFlagSet("test", flag.ContinueOnError) cf_debug_server.AddFlags(flags) f := flags.Lookup(cf_debug_server.DebugFlag) Expect(f).NotTo(BeNil())
func main() { flag.Parse() if !*dev && (*httpUsername == "" || (*httpHashedPassword == "" && *httpPassword == "")) { fatal(errors.New("must specify -httpUsername and -httpPassword or -httpHashedPassword or turn on dev mode")) } if _, err := os.Stat(*templatesDir); err != nil { fatal(errors.New("directory specified via -templates does not exist")) } if _, err := os.Stat(*publicDir); err != nil { fatal(errors.New("directory specified via -public does not exist")) } logger := lager.NewLogger("atc") logLevel := lager.INFO if *dev { logLevel = lager.DEBUG } sink := lager.NewReconfigurableSink(lager.NewWriterSink(os.Stdout, lager.DEBUG), logLevel) logger.RegisterSink(sink) var err error var dbConn Db.Conn for { dbConn, err = migration.Open(*sqlDriver, *sqlDataSource, migrations.Migrations) if err != nil { if strings.Contains(err.Error(), " dial ") { logger.Error("failed-to-open-db", err) time.Sleep(5 * time.Second) continue } fatal(err) } break } dbConn = Db.Explain(logger, dbConn, 500*time.Millisecond) listener := pq.NewListener(*sqlDataSource, time.Second, time.Minute, nil) bus := Db.NewNotificationsBus(listener) db := Db.NewSQL(logger.Session("db"), dbConn, bus) pipelineDBFactory := Db.NewPipelineDBFactory(logger.Session("db"), dbConn, bus, db) var configDB Db.ConfigDB configDB = Db.PlanConvertingConfigDB{db} var resourceTypesNG []atc.WorkerResourceType err = json.Unmarshal([]byte(*resourceTypes), &resourceTypesNG) if err != nil { logger.Fatal("invalid-resource-types", err) } var workerClient worker.Client if *gardenAddr != "" { workerClient = worker.NewGardenWorker( gclient.New(gconn.NewWithLogger( *gardenNetwork, *gardenAddr, logger.Session("garden-connection"), )), clock.NewClock(), -1, resourceTypesNG, "linux", []string{}, ) } else { workerClient = worker.NewPool(worker.NewDBWorkerProvider(db, logger)) } resourceTracker := resource.NewTracker(workerClient) gardenFactory := exec.NewGardenFactory(workerClient, resourceTracker, func() string { guid, err := uuid.NewV4() if err != nil { panic("not enough entropy to generate guid: " + err.Error()) } return guid.String() }) execEngine := engine.NewExecEngine(gardenFactory, engine.NewBuildDelegateFactory(db), db) engine := engine.NewDBEngine(engine.Engines{execEngine}, db, db) var webValidator auth.Validator if *httpUsername != "" && *httpHashedPassword != "" { webValidator = auth.BasicAuthHashedValidator{ Username: *httpUsername, HashedPassword: *httpHashedPassword, } } else if *httpUsername != "" && *httpPassword != "" { webValidator = auth.BasicAuthValidator{ Username: *httpUsername, Password: *httpPassword, } } else { webValidator = auth.NoopValidator{} } callbacksURL, err := url.Parse(*callbacksURLString) if err != nil { fatal(err) } drain := make(chan struct{}) apiHandler, err := api.NewHandler( logger, // logger lager.Logger, webValidator, // validator auth.Validator, pipelineDBFactory, // pipelineDBFactory db.PipelineDBFactory, configDB, // configDB db.ConfigDB, db, // buildsDB buildserver.BuildsDB, db, // workerDB workerserver.WorkerDB, db, // pipeDB pipes.PipeDB, db, // pipelinesDB db.PipelinesDB, config.ValidateConfig, // configValidator configserver.ConfigValidator, callbacksURL.String(), // peerURL string, buildserver.NewEventHandler, // eventHandlerFactory buildserver.EventHandlerFactory, drain, // drain <-chan struct{}, engine, // engine engine.Engine, workerClient, // workerClient worker.Client, sink, // sink *lager.ReconfigurableSink, *cliDownloadsDir, // cliDownloadsDir string, ) if err != nil { fatal(err) } radarSchedulerFactory := pipelines.NewRadarSchedulerFactory( resourceTracker, *checkInterval, db, engine, db, ) webHandler, err := web.NewHandler( logger, webValidator, radarSchedulerFactory, db, pipelineDBFactory, configDB, *templatesDir, *publicDir, engine, ) if err != nil { fatal(err) } webMux := http.NewServeMux() webMux.Handle("/api/v1/", apiHandler) webMux.Handle("/", webHandler) var httpHandler http.Handler httpHandler = webMux if !*publiclyViewable { httpHandler = auth.Handler{ Handler: httpHandler, Validator: webValidator, } } // copy Authorization header as ATC-Authorization cookie for websocket auth httpHandler = auth.CookieSetHandler{ Handler: httpHandler, } httpHandler = httpmetrics.Wrap(httpHandler) webListenAddr := fmt.Sprintf("%s:%d", *webListenAddress, *webListenPort) debugListenAddr := fmt.Sprintf("%s:%d", *debugListenAddress, *debugListenPort) syncer := pipelines.NewSyncer( logger.Session("syncer"), db, pipelineDBFactory, func(pipelineDB Db.PipelineDB) ifrit.Runner { return grouper.NewParallel(os.Interrupt, grouper.Members{ { pipelineDB.ScopedName("radar"), rdr.NewRunner( logger.Session(pipelineDB.ScopedName("radar")), *noop, db, radarSchedulerFactory.BuildRadar(pipelineDB), pipelineDB, 1*time.Minute, ), }, { pipelineDB.ScopedName("scheduler"), &sched.Runner{ Logger: logger.Session(pipelineDB.ScopedName("scheduler")), Locker: db, DB: pipelineDB, Scheduler: radarSchedulerFactory.BuildScheduler(pipelineDB), Noop: *noop, Interval: 10 * time.Second, }, }, }) }, ) buildTracker := builds.NewTracker( logger.Session("build-tracker"), db, engine, ) memberGrouper := []grouper.Member{ {"web", http_server.New(webListenAddr, httpHandler)}, {"debug", http_server.New(debugListenAddr, http.DefaultServeMux)}, {"drainer", ifrit.RunFunc(func(signals <-chan os.Signal, ready chan<- struct{}) error { close(ready) <-signals close(drain) return nil })}, {"pipelines", pipelines.SyncRunner{ Syncer: syncer, Interval: 10 * time.Second, Clock: clock.NewClock(), }}, {"builds", builds.TrackerRunner{ Tracker: buildTracker, Interval: 10 * time.Second, Clock: clock.NewClock(), }}, } group := grouper.NewParallel(os.Interrupt, memberGrouper) running := ifrit.Envoke(sigmon.New(group)) logger.Info("listening", lager.Data{ "web": webListenAddr, "debug": debugListenAddr, }) err = <-running.Wait() if err != nil { logger.Error("exited-with-failure", err) os.Exit(1) } }