func InitLoggerFromConfig(logger lager.Logger, c *config.Config, logCounter *schema.LogCounter) { if c.Logging.File != "" { file, err := os.OpenFile(c.Logging.File, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666) if err != nil { logger.Fatal("error-opening-log-file", err, lager.Data{"file": c.Logging.File}) } var logLevel lager.LogLevel switch c.Logging.Level { case DEBUG: logLevel = lager.DEBUG case INFO: logLevel = lager.INFO case ERROR: logLevel = lager.ERROR case FATAL: logLevel = lager.FATAL default: panic(fmt.Errorf("unknown log level: %s", c.Logging.Level)) } logger.RegisterSink(lager.NewWriterSink(file, logLevel)) } logger.RegisterSink(logCounter) }
var _ = Describe("Logger", func() { var logger lager.Logger var testSink *lagertest.TestSink var component = "my-component" var action = "my-action" var logData = lager.Data{ "foo": "bar", "a-number": 7, } BeforeEach(func() { logger = lager.NewLogger(component) testSink = lagertest.NewTestSink() logger.RegisterSink(testSink) }) var TestCommonLogFeatures = func(level lager.LogLevel) { var log lager.LogFormat BeforeEach(func() { log = testSink.Logs()[0] }) It("writes a log to the sink", func() { Ω(testSink.Logs()).Should(HaveLen(1)) }) It("records the source component", func() { Ω(log.Source).Should(Equal(component))
flag.StringVar(&reportName, "reportName", "report", "report name") } func TestAuction(t *testing.T) { RegisterFailHandler(Fail) RunSpecs(t, "Auction Suite") } var _ = BeforeSuite(func() { runtime.GOMAXPROCS(runtime.NumCPU()) fmt.Printf("Running in %s communicationMode\n", communicationMode) startReport() logger = lager.NewLogger("sim") logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG)) sessionsToTerminate = []*gexec.Session{} switch communicationMode { case InProcess: cells = buildInProcessReps() case HTTP: cells = launchExternalHTTPReps() default: panic(fmt.Sprintf("unknown communication mode: %s", communicationMode)) } }) var _ = BeforeEach(func() { var err error workPool, err = workpool.NewWorkPool(workers)
func TestGlager(t *testing.T) { RegisterFailHandler(Fail) RunSpecs(t, "Glager Test Suite") } var _ = Describe(".ContainSequence", func() { var ( buffer *gbytes.Buffer logger lager.Logger expectedSource = "some-source" ) BeforeEach(func() { buffer = gbytes.NewBuffer() logger = lager.NewLogger(expectedSource) logger.RegisterSink(lager.NewWriterSink(buffer, lager.DEBUG)) }) Context("when actual contains an entry", func() { var ( action = "some-action" expectedAction = fmt.Sprintf("%s.%s", expectedSource, action) expectedDataKey = "some-key" expectedDataValue = "some-value" ) Context("that is an info", func() { BeforeEach(func() { logger.Info(action, lager.Data{expectedDataKey: expectedDataValue}) })
. "github.com/onsi/ginkgo" . "github.com/onsi/gomega" ) var _ = Describe("Chug", func() { var ( logger lager.Logger stream chan Entry pipeReader *io.PipeReader pipeWriter *io.PipeWriter ) BeforeEach(func() { pipeReader, pipeWriter = io.Pipe() logger = lager.NewLogger("chug-test") logger.RegisterSink(lager.NewWriterSink(pipeWriter, lager.DEBUG)) stream = make(chan Entry, 100) go Chug(pipeReader, stream) }) AfterEach(func() { pipeWriter.Close() Eventually(stream).Should(BeClosed()) }) Context("when fed a stream of well-formed lager messages", func() { It("should return parsed lager messages", func() { data := lager.Data{"some-float": 3.0, "some-string": "foo"} logger.Debug("chug", data) logger.Info("again", data)
var _ = Describe("Client", func() { var ( fakeRegion aws.Region goamzBucketClient *goamz.Bucket bucketName string log *gbytes.Buffer logger lager.Logger ) BeforeEach(func() { bucketName = "i_am_bucket" logger = lager.NewLogger("logger") log = gbytes.NewBuffer() logger.RegisterSink(lager.NewWriterSink(log, lager.INFO)) fakeRegion = aws.Region{ Name: "fake_region", S3Endpoint: fakeS3EndpointURL, S3LocationConstraint: true, } goamzBucketClient = goamz.New(aws.Auth{}, fakeRegion).Bucket(bucketName) }) Describe("GetOrCreateBucket", func() { Context("when the bucket already exists", func() { var ( err error bucket s3.Bucket )
var _ = Describe("V2MessageStatusUpdater", func() { var ( updater postal.V2MessageStatusUpdater messagesRepo *mocks.MessagesRepository logger lager.Logger buffer *bytes.Buffer conn *mocks.Connection ) BeforeEach(func() { conn = mocks.NewConnection() messagesRepo = mocks.NewMessagesRepository() buffer = bytes.NewBuffer([]byte{}) logger = lager.NewLogger("notifications") logger.RegisterSink(lager.NewWriterSink(buffer, lager.INFO)) updater = postal.NewV2MessageStatusUpdater(messagesRepo) }) It("updates the status of the message", func() { updater.Update(conn, "some-message-id", "message-status", "campaign-id", logger) Expect(messagesRepo.UpdateCall.Receives.Connection).To(Equal(conn)) Expect(messagesRepo.UpdateCall.Receives.Message).To(Equal(models.Message{ ID: "some-message-id", Status: "message-status", CampaignID: "campaign-id", })) })
enqueue chan<- models.Task process ifrit.Process fakeServer *ghttp.Server logger lager.Logger timeout time.Duration ) BeforeEach(func() { timeout = 1 * time.Second cf_http.Initialize(timeout) fakeServer = ghttp.NewServer() logger = lager.NewLogger("task-watcher-test") logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.INFO)) fakeBBS = new(fake_bbs.FakeReceptorBBS) taskWorker, enqueueTasks := task_handler.NewTaskWorkerPool(fakeBBS, logger) enqueue = enqueueTasks process = ifrit.Invoke(taskWorker) }) AfterEach(func() { fakeServer.Close() ginkgomon.Kill(process) })
var _ = Describe("Mail", func() { var ( mailServer *SMTPServer client *mail.Client logger lager.Logger buffer *bytes.Buffer config mail.Config ) BeforeEach(func() { var err error buffer = &bytes.Buffer{} logger = lager.NewLogger("notifications") logger.RegisterSink(lager.NewWriterSink(buffer, 0)) mailServer = NewSMTPServer("user", "pass") config = mail.Config{ User: "******", Pass: "******", TestMode: false, SkipVerifySSL: true, DisableTLS: false, } config.Host, config.Port, err = net.SplitHostPort(mailServer.URL.String()) if err != nil { panic(err) }
var _ = Describe("Instance Backuper", func() { var ( providerFactory *fakes.FakeProviderFactory redisClient *fakes.FakeRedisClient redisBackuper *fakes.FakeRedisBackuper redisConfigFinder *fakes.FakeRedisConfigFinder instanceIDLocator *fakes.FakeInstanceIDLocator backupConfig *backup.BackupConfig logger lager.Logger log *gbytes.Buffer ) BeforeEach(func() { log = gbytes.NewBuffer() logger = lager.NewLogger("logger") logger.RegisterSink(lager.NewWriterSink(log, lager.DEBUG)) providerFactory = new(fakes.FakeProviderFactory) redisClient = new(fakes.FakeRedisClient) providerFactory.RedisClientProviderReturns(redisClient, nil) redisBackuper = new(fakes.FakeRedisBackuper) providerFactory.RedisBackuperProviderReturns(redisBackuper) redisConfigFinder = new(fakes.FakeRedisConfigFinder) providerFactory.RedisConfigFinderProviderReturns(redisConfigFinder) instanceIDLocator = new(fakes.FakeInstanceIDLocator) providerFactory.SharedInstanceIDLocatorProviderReturns(instanceIDLocator) providerFactory.DedicatedInstanceIDLocatorProviderReturns(instanceIDLocator)
"github.com/onsi/gomega/gbytes" ) var _ = Describe("Unify", func() { var loggerA, loggerB lager.Logger var bufferA, bufferB *bytes.Buffer var t0, t1 time.Time BeforeEach(func() { loggerA = lager.NewLogger("A") loggerB = lager.NewLogger("B") bufferA = &bytes.Buffer{} bufferB = &bytes.Buffer{} loggerA.RegisterSink(lager.NewWriterSink(bufferA, lager.DEBUG)) loggerB.RegisterSink(lager.NewWriterSink(bufferB, lager.DEBUG)) bufferA.Write([]byte("non-lager-A\n")) bufferB.Write([]byte("non-lager-B-1\n")) loggerA.Info("A-1") time.Sleep(10 * time.Millisecond) t0 = time.Now() time.Sleep(10 * time.Millisecond) loggerB.Info("B-1") loggerA.Info("A-2") loggerB.Info("B-2") loggerB.Info("B-3")