Ejemplo n.º 1
0
func TestDefaultLevels(t *testing.T) {
	buf := bytes.Buffer{}
	logger := levels.New(log.NewLogfmtLogger(&buf))

	logger.Debug().Log("msg", "résumé") // of course you'd want to do this
	if want, have := "level=debug msg=résumé\n", buf.String(); want != have {
		t.Errorf("want %#v, have %#v", want, have)
	}

	buf.Reset()
	logger.Info().Log("msg", "Åhus")
	if want, have := "level=info msg=Åhus\n", buf.String(); want != have {
		t.Errorf("want %#v, have %#v", want, have)
	}

	buf.Reset()
	logger.Error().Log("msg", "© violation")
	if want, have := "level=error msg=\"© violation\"\n", buf.String(); want != have {
		t.Errorf("want %#v, have %#v", want, have)
	}

	buf.Reset()
	logger.Crit().Log("msg", "	")
	if want, have := "level=crit msg=\"\\t\"\n", buf.String(); want != have {
		t.Errorf("want %#v, have %#v", want, have)
	}
}
Ejemplo n.º 2
0
func ExampleLevels() {
	logger := levels.New(log.NewLogfmtLogger(os.Stdout))
	logger.Debug("msg", "hello")
	logger.With("context", "foo").Warn("err", "error")

	// Output:
	// level=debug msg=hello
	// level=warn context=foo err=error
}
Ejemplo n.º 3
0
// StartApplicationSQSConsumer creates a Go-routine that consumes from an SQS queue
func StartApplicationSQSConsumer(logger kitlog.Logger, root context.Context, errc chan error, c *config.Configuration) {
	go func() {
		ctx, cancel := context.WithCancel(root)
		defer cancel()

		l := levlog.New(logger)
		l.Info().Log("ApplicationSQSConsumer queue", c.QueueName, "transport", "SQS")

		errc <- consumeMessagesFromQueue(l, ctx, c)
	}()
}
Ejemplo n.º 4
0
// StartHealthCheckHTTPListener creates a Go-routine that has an HTTP listener for the healthcheck endpoint
func StartHealthCheckHTTPListener(logger kitlog.Logger, root context.Context, errc chan error, c *config.Configuration) {
	go func() {
		ctx, cancel := context.WithCancel(root)
		defer cancel()

		l := levlog.New(logger)
		l.Info().Log("HealthCheckAddress", c.HealthCheckAddress, "transport", "HTTP/JSON")

		router := createHealthCheckRouter(logger, ctx, endpoint.NewHealthCheck(c))
		errc <- http.ListenAndServe(c.HealthCheckAddress, router)
	}()
}
Ejemplo n.º 5
0
func TestModifiedLevels(t *testing.T) {
	buf := bytes.Buffer{}
	logger := levels.New(
		log.NewJSONLogger(&buf),
		levels.Key("l"),
		levels.DebugValue("dbg"),
	)
	logger.With("easter_island", "176°").Debug("msg", "moai")
	if want, have := `{"easter_island":"176°","l":"dbg","msg":"moai"}`+"\n", buf.String(); want != have {
		t.Errorf("want %#v, have %#v", want, have)
	}
}
Ejemplo n.º 6
0
// StartApplicationHTTPListener creates a Go-routine that has an HTTP listener sensor readings
func StartApplicationHTTPListener(logger kitlog.Logger, root context.Context, errc chan error, c *config.Configuration) {
	go func() {
		ctx, cancel := context.WithCancel(root)
		defer cancel()

		l := levlog.New(logger)
		l.Info().Log("ApplicationAddress", c.ApplicationAddress, "transport", "HTTP/JSON")

		router := createApplicationRouter(logger, ctx, c, endpoint.NewSensorReadingServicer(c))
		errc <- http.ListenAndServe(c.ApplicationAddress, router)
	}()
}
Ejemplo n.º 7
0
func init() {
	termLog = log.NewLogfmtLogger(os.Stderr)
	if term.IsTerminal(os.Stderr) {
		termLog = term.NewLogger(
			os.Stderr,
			log.NewLogfmtLogger,
			kithlp.NewLevelColorer("level", nil),
		)
	}
	logBase.Swap(termLog)
	lg := kithlp.StringifyLogger{logBase}
	Logger = log.NewContext(lg).With("ts", log.DefaultTimestampUTC, "caller", log.Caller(4))
	logger = levels.New(Logger)

	stdlog.SetOutput(log.NewStdlibAdapter(logBase))
	converter.Logger.Swap(Logger)
}
Ejemplo n.º 8
0
func main() {
	var (
		listen = flag.String("listen", ":8080", "HTTP listen address")
		// proxy  = flag.String("proxy", "", "Optional comma-separated list of URLs to proxy uppercase requests")
	)
	flag.Parse()

	var logger log.Logger
	logger = log.NewLogfmtLogger(os.Stderr)
	logger = log.NewContext(logger).With("listen", *listen).With("caller", log.DefaultCaller)
	loglevel := levels.New(logger)

	ctx := context.Background()

	redisURL := os.Getenv("REDIS_URL")
	redisPassword := os.Getenv("REDIS_PASSWORD")
	if redisURL == "" || redisPassword == "" {
		_ = loglevel.Crit("err", "missing REDIS connection information")
		return
	}

	infra, err := BuildInfrastructure(InfrastructureOptions{
		DialURL:    os.Getenv("REDIS_URL"),
		DialOption: []redis.DialOption{redis.DialPassword(redisPassword)},
	})
	if err != nil {
		_ = loglevel.Crit("err", fmt.Sprintf("Infrastructure error: %v", err))
		return
	}
	defer infra.conn.Close()

	var svc CacheService
	svc = cacheService{}
	svc = loggingMiddleware(logger)(svc)

	cacheHandler := httptransport.NewServer(
		ctx,
		makeCacheEndpoint(svc),
		decodeCacheRequest,
		encodeResponse,
	)

	http.Handle("/cache", cacheHandler)
	_ = logger.Log("msg", "HTTP", "addr", *listen)
	_ = logger.Log("err", http.ListenAndServe(*listen, nil))
}
Ejemplo n.º 9
0
package converter

import (
	"os"
	"os/exec"
	"path/filepath"
	"time"

	"github.com/go-kit/kit/log"
	"github.com/go-kit/kit/log/levels"
	"github.com/stvp/go-toml-config"
)

// Swappable logger,
var Logger = new(log.SwapLogger)
var logger = levels.New(log.NewContext(Logger).With("lib", "converter"))

func init() {
	Logger.Swap(log.NewNopLogger())
}

var (
	// ConfPdftk is the path for PdfTk
	ConfPdftk = config.String("pdftk", "pdftk")

	// ConfPdfseparate is the path for pdfseparate (member of poppler-utils
	ConfPdfseparate = config.String("pdfseparate", "pdfseparate")

	// ConfLoffice is the path for LibreOffice
	ConfLoffice = config.String("loffice", "loffice")
Ejemplo n.º 10
0
package leveledLogger

import (
	"bytes"
	"testing"

	"github.com/go-kit/kit/log"
	"github.com/go-kit/kit/log/levels"
)

var (
	adapter = log.NewStdlibAdapter(log.NewNopLogger(),
		log.TimestampKey(""), log.FileKey(""), log.MessageKey(""),
	)
	baseLogger = log.NewLogfmtLogger(adapter)
	kitleveler = levels.New(baseLogger)
)

func BenchmarkInfo_KitLevels(b *testing.B) {
	for i := 0; i < b.N; i++ {
		kitleveler.Info().Log(
			"key1", "first value is main message string",
			"key2", "file:line",
			"key3", "timestamp",
			"key4", "fake error string in case an error occurred",
		)
	}
}

var (
	buffer = new(bytes.Buffer)
Ejemplo n.º 11
0
	"fmt"
	stdlog "log"
	"net/http"
	"os"
	"strings"
	"sync"

	"github.com/go-kit/kit/log"
	"github.com/go-kit/kit/log/levels"
	"github.com/juju/persistent-cookiejar"
	"github.com/spf13/cobra"
)

var (
	logger = log.NewLogfmtLogger(os.Stderr)
	Log    = levels.New(logger)
)

type config struct {
	SystemID                   string
	BaseURL, DataURL, LogonURL string
	CookieJarPath              string

	dateFormat string
	initURLs   sync.Once

	jar   *cookiejar.Jar
	jarMu sync.Mutex
	*http.Client
	initClient sync.Once
}
Ejemplo n.º 12
0
	"github.com/tgulacsi/go/temp"
	"gopkg.in/errgo.v1"
)

var (
	// Logger is the base logger, can be swapped - defaults to NopLogger.
	Logger = new(log.SwapLogger)

	// CheckEncoding is true if we should check Base64 encodings
	CheckEncoding = true

	// SaveBadInput is true if we should save bad input
	SaveBadInput = false

	// logger is the package-level logger.
	logger = levels.New(log.NewContext(Logger).With("lib", "i18nmail"))
)

func init() {
	Logger.Swap(log.NewNopLogger())
}

// TodoFunc is the type of the function called by Walk and WalkMultipart.
type TodoFunc func(mp MailPart) error

// sequence is a global sequence for numbering mail parts.
var sequence uint64

func nextSeq() uint64 {
	return atomic.AddUint64(&sequence, 1)
}
Ejemplo n.º 13
0
Archivo: log.go Proyecto: sevein/qubot
	// application.
	InfoLevel
	// DebugLevel level. Usually only enabled when debugging. Very verbose
	// logging.
	DebugLevel
)

// currentLevel has a default and it's updated later by levelFlag
var currentLevel = InfoLevel

var (
	logger = log.NewLogfmtLogger(os.Stderr)
	ctx    = log.NewContext(logger).With("ts", log.DefaultTimestampUTC)

	// Logger is the global application logger
	Logger = levels.New(ctx).With("caller", log.Caller(5))
)

type levelFlag struct{}

// String implements flag.Value.
func (f levelFlag) String() string {
	return fmt.Sprint(currentLevel)
}

// Set implements flag.Value.
func (f levelFlag) Set(level string) (err error) {
	currentLevel, err = ParseLevel(level)
	return err
}
Ejemplo n.º 14
0
func NoopLogger() *CoreLogger {
	return NewCoreLogger(levels.New(kitlog.NewNopLogger()))
}
Ejemplo n.º 15
0
func LogfmtLoggerTo(writer io.Writer) *CoreLogger {
	return NewCoreLogger(levels.New(kitlog.NewLogfmtLogger(writer)))
}
Ejemplo n.º 16
0
func JSONLoggerTo(writer io.Writer) *CoreLogger {
	return NewCoreLogger(levels.New(kitlog.NewJSONLogger(writer)))
}