src/lib/syslog/go/logger.go - fuchsia - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 //go:build !build_with_native_toolchain

 package syslog

 import (
 	"context"
 	"encoding/binary"
 	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"math"
 	"os"
 	"runtime"
 	"strconv"
 	"strings"
 	"sync/atomic"
 	"syscall/zx"
 	"unicode/utf8"

 	"fidl/fuchsia/diagnostics"
 	"fidl/fuchsia/logger"
 )

 // ErrMsgTooLong is returned when a message is truncated.
 type ErrMsgTooLong struct {
 	// Msg is the truncated part of the message.
 	Msg string
 }

 func (e *ErrMsgTooLong) Error() string {
 	return "too long message was truncated"
 }

 const (
 	_ uint8 = iota
 	DebugVerbosity
 	TraceVerbosity
 )

 type LogLevel int8

 const (
 	TraceLevel   = LogLevel(logger.LogLevelFilterTrace)
 	DebugLevel   = LogLevel(logger.LogLevelFilterDebug)
 	InfoLevel    = LogLevel(logger.LogLevelFilterInfo)
 	WarningLevel = LogLevel(logger.LogLevelFilterWarn)
 	ErrorLevel   = LogLevel(logger.LogLevelFilterError)
 	FatalLevel   = LogLevel(logger.LogLevelFilterFatal)
 	NoneLevel    = LogLevel(logger.LogLevelFilterNone)
 )

 var _ flag.Value = (*LogLevel)(nil)

 // Set implements the flag.Value interface.
 func (ll *LogLevel) Set(s string) error {
 	s = strings.ToUpper(s)
 	lls := logLevelFromString(s)
 	if lls != NoneLevel {
 		*ll = lls
 		return nil
 	}
 	v, err := strconv.Atoi(s)
 	if err != nil {
 		return err
 	}
 	*ll = LogLevel(v)
 	return nil
 }

 func logLevelFromString(s string) LogLevel {
 	switch s {
 	case "ALL":
 		return math.MinInt8
 	case "TRACE":
 		return TraceLevel
 	case "DEBUG":
 		return DebugLevel
 	case "INFO":
 		return InfoLevel
 	case "WARNING":
 		return WarningLevel
 	case "ERROR":
 		return ErrorLevel
 	case "FATAL":
 		return FatalLevel
 	default:
 		return NoneLevel
 	}
 }

 func (ll LogLevel) String() string {
 	switch ll {
 	case math.MinInt8:
 		return "ALL"
 	case TraceLevel:
 		return "TRACE"
 	case DebugLevel:
 		return "DEBUG"
 	case InfoLevel:
 		return "INFO"
 	case WarningLevel:
 		return "WARNING"
 	case ErrorLevel:
 		return "ERROR"
 	case FatalLevel:
 		return "FATAL"
 	default:
 		return fmt.Sprintf("LOG(%d)", ll)
 	}
 }

 type Writer struct {
 	*Logger
 }

 func (l *Writer) Write(data []byte) (n int, err error) {
 	origLen := len(data)

 	// Strip out the trailing newline the `log` library adds because the
 	// logging service also adds a trailing newline.
 	if len(data) > 0 && data[len(data)-1] == '\n' {
 		data = data[:len(data)-1]
 	}

 	if err := l.Infof("%s", data); err != nil {
 		return 0, err
 	}

 	return origLen, nil
 }

 type logOptions struct {
 	LogSink                       *logger.LogSinkWithCtxInterface
 	MinSeverityForFileAndLineInfo LogLevel
 	Tags                          []string
 	Writer                        io.Writer
 }

 type LogInitOptions struct {
 	logOptions
 	LogLevel LogLevel
 }

 type Logger struct {
 	socket zx.Socket
 	cancel context.CancelFunc

 	droppedLogs uint32
 	options     logOptions
 	level       int32 // LogLevel; accessed atomically.
 	pid         uint64
 }

 func NewLogger(options LogInitOptions) (*Logger, error) {
 	if l, max := len(options.Tags), int(logger.MaxTags); l > max {
 		return nil, fmt.Errorf("too many tags: %d/%d", l, max)
 	}
 	for _, tag := range options.Tags {
 		if l, max := len(tag), int(logger.MaxTagLenBytes); l > max {
 			return nil, fmt.Errorf("tag too long: %d/%d", l, max)
 		}
 	}
 	l := Logger{
 		options: options.logOptions,
 		level:   int32(options.LogLevel),
 		pid:     uint64(os.Getpid()),
 	}
 	if logSink := options.LogSink; logSink != nil {
 		const tag = "syslog"
 		ctx, cancel := context.WithCancel(context.Background())
 		l.cancel = func() {
 			cancel()
 			if err := logSink.Close(); err != nil {
 				_ = l.WarnTf(tag, "fuchsia.logger/LogSink.Close(): %s", err)
 			}
 		}

 		localS, peerS, err := zx.NewSocket(zx.SocketDatagram)
 		if err != nil {
 			_ = l.Close()
 			return nil, err
 		}
 		l.socket = localS
 		if err := logSink.Connect(context.Background(), peerS); err != nil {
 			_ = l.Close()
 			return nil, err
 		}

 		initLevel := options.LogLevel
 		go func() {
 			for {
 				_ = l.InfoTf(tag, "calling fuchsia.logger/LogSink.WaitForInterestChange...")
 				interest, err := logSink.WaitForInterestChange(ctx)
 				if err != nil {
 					func() {
 						switch err := err.(type) {
 						case *zx.Error:
 							switch err.Status {
 							case zx.ErrBadHandle, zx.ErrCanceled, zx.ErrPeerClosed:
 								return
 							}
 							_ = l.WarnTf(tag, "fuchsia.logger/LogSink.WaitForInterestChange(): %s", err)
 						}
 					}()
 					return
 				}
 				switch interest.Which() {
 				case logger.LogSinkWaitForInterestChangeResultResponse:
 					if interest.Response.Data.HasMinSeverity() {
 						minSeverity := interest.Response.Data.GetMinSeverity()
 						l.SetSeverity(minSeverity)
 						_ = l.InfoTf(tag, "fuchsia.logger/LogSink.WaitForInterestChange({MinSeverity: %s})", minSeverity)
 					} else {
 						_ = l.InfoTf(tag, "fuchsia.logger/LogSink.WaitForInterestChange({})")
 						l.SetSeverity(diagnostics.Severity(initLevel))
 					}
 				case logger.LogSinkWaitForInterestChangeResultErr:
 					_ = l.ErrorTf(tag, "fuchsia.logger/LogSink.WaitForInterestChange(): %s", interest.Err)
 					return
 				}
 			}
 		}()
 	}
 	return &l, nil
 }

 func NewLoggerWithDefaults(tags ...string) (*Logger, error) {
 	options := LogInitOptions{
 		LogLevel: InfoLevel,
 	}
 	options.MinSeverityForFileAndLineInfo = ErrorLevel
 	options.Tags = tags
 	return NewLogger(options)
 }

 func (l *Logger) Close() error {
 	l.cancel()
 	return l.socket.Close()
 }

 func (l *Logger) logToWriter(writer io.Writer, time zx.Time, logLevel LogLevel, tag, msg string) error {
 	if writer == nil {
 		writer = os.Stderr
 	}
 	var tagsStorage [logger.MaxTags + 1]string
 	tags := tagsStorage[:0]
 	for _, tag := range l.options.Tags {
 		if len(tag) > 0 {
 			tags = append(tags, tag)
 		}
 	}
 	if len(tag) > 0 {
 		tags = append(tags, tag)
 	}
 	var buffer [int(logger.MaxTags+1) * int(logger.MaxTagLenBytes)]byte
 	pos := 0
 	for i, tag := range tags {
 		if i > 0 {
 			pos += copy(buffer[pos:], ", ")
 		}
 		pos += copy(buffer[pos:], tag)
 	}
 	_, err := fmt.Fprintf(writer, "[%05d.%06d][%d][0][%s] %s: %s\n", time/1000000000, (time/1000)%1000000, l.pid, buffer[:pos], logLevel, msg)
 	return err
 }

 func (l *Logger) logToSocket(time zx.Time, logLevel LogLevel, tag, msg string) error {
 	const golangThreadID = 0

 	var buffer [logger.MaxDatagramLenBytes]byte

 	pos := 0
 	for _, i := range [...]uint64{
 		l.pid,
 		golangThreadID,
 		uint64(time),
 	} {
 		binary.LittleEndian.PutUint64(buffer[pos:], i)
 		pos += 8
 	}
 	for _, i := range [...]uint32{
 		uint32(logLevel),
 		atomic.LoadUint32(&l.droppedLogs),
 	} {
 		binary.LittleEndian.PutUint32(buffer[pos:], i)
 		pos += 4
 	}

 	// Write global tags
 	for _, tag := range l.options.Tags {
 		if length := len(tag); length != 0 {
 			buffer[pos] = byte(length)
 			pos += 1
 			pos += copy(buffer[pos:], tag)
 		}
 	}

 	// Write local tags
 	if length := len(tag); length != 0 {
 		buffer[pos] = byte(length)
 		pos += 1
 		pos += copy(buffer[pos:], tag)
 	}

 	const ellipsis = "..."

 	// Write msg
 	buffer[pos] = 0
 	pos += 1

 	payload := msg
 	if len(payload)+1 > len(buffer)-pos {
 		payload = payload[:len(buffer)-pos-1-len(ellipsis)]

 		// Remove the last byte until the result is valid UTF-8.
 		for {
 			if lastRune, _ := utf8.DecodeLastRuneInString(payload); lastRune != utf8.RuneError {
 				break
 			}
 			payload = payload[:len(payload)-1]
 		}
 	}
 	pos += copy(buffer[pos:], payload)
 	if payload != msg {
 		pos += copy(buffer[pos:], ellipsis)
 	}

 	buffer[pos] = 0
 	pos += 1

 	if _, err := l.socket.Write(buffer[:pos], 0); err != nil {
 		atomic.AddUint32(&l.droppedLogs, 1)
 		return err
 	}

 	if payload != msg {
 		return &ErrMsgTooLong{Msg: msg[len(payload):]}
 	}
 	return nil
 }

 func (l *Logger) logf(callDepth int, logLevel LogLevel, tag string, format string, a ...interface{}) error {
 	if LogLevel(atomic.LoadInt32(&l.level)) > logLevel {
 		return nil
 	}
 	time := zx.Sys_clock_get_monotonic()
 	msg := fmt.Sprintf(format, a...)
 	if logLevel >= l.options.MinSeverityForFileAndLineInfo {
 		_, file, line, ok := runtime.Caller(callDepth)
 		if !ok {
 			file = "???"
 			line = 0
 		} else {
 			short := file
 			for i := len(file) - 1; i > 0; i-- {
 				if file[i] == '/' {
 					short = file[i+1:]
 					break
 				}
 			}
 			file = short
 		}
 		msg = fmt.Sprintf("%s(%d): %s ", file, line, msg)
 	}
 	if len(tag) > int(logger.MaxTagLenBytes) {
 		tag = tag[:logger.MaxTagLenBytes]
 	}
 	if logLevel == FatalLevel {
 		defer os.Exit(1)
 	}
 	if atomic.LoadUint32((*uint32)(&l.socket)) != uint32(zx.HandleInvalid) {
 		switch err := l.logToSocket(time, logLevel, tag, msg).(type) {
 		case *zx.Error:
 			switch err.Status {
 			case zx.ErrPeerClosed, zx.ErrBadState:
 				atomic.StoreUint32((*uint32)(&l.socket), uint32(zx.HandleInvalid))
 			default:
 				return err
 			}
 		default:
 			return err
 		}
 	}
 	return l.logToWriter(l.options.Writer, time, logLevel, tag, msg)
 }

 func (l *Logger) SetSeverity(severity diagnostics.Severity) {
 	atomic.StoreInt32(&l.level, int32(severity))
 }

 // severityFromVerbosity provides the severity corresponding to the given
 // verbosity. Note that verbosity relative to the default severity and can
 // be thought of as incrementally "more vebose than" the baseline.
 func severityFromVerbosity(verbosity uint8) LogLevel {
 	level := InfoLevel - LogLevel(verbosity*logger.LogVerbosityStepSize)
 	// verbosity scale sits in the interstitial space between INFO and DEBUG
 	if level < (DebugLevel + 1) {
 		return DebugLevel + 1
 	}
 	return level
 }

 func (l *Logger) SetVerbosity(verbosity uint8) {
 	atomic.StoreInt32(&l.level, int32(severityFromVerbosity(verbosity)))
 }

 const DefaultCallDepth = 2

 func (l *Logger) Tracef(format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, TraceLevel, "", format, a...)
 }

 func (l *Logger) Debugf(format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, DebugLevel, "", format, a...)
 }

 func (l *Logger) Infof(format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, InfoLevel, "", format, a...)
 }

 func (l *Logger) Warnf(format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, WarningLevel, "", format, a...)
 }

 func (l *Logger) Errorf(format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, ErrorLevel, "", format, a...)
 }

 func (l *Logger) Fatalf(format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, FatalLevel, "", format, a...)
 }

 func (l *Logger) VLogf(verbosity uint8, format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, severityFromVerbosity(verbosity), "", format, a...)
 }

 func (l *Logger) TraceTf(tag, format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, TraceLevel, tag, format, a...)
 }

 func (l *Logger) DebugTf(tag, format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, DebugLevel, tag, format, a...)
 }

 func (l *Logger) InfoTf(tag, format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, InfoLevel, tag, format, a...)
 }

 func (l *Logger) WarnTf(tag, format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, WarningLevel, tag, format, a...)
 }

 func (l *Logger) ErrorTf(tag, format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, ErrorLevel, tag, format, a...)
 }

 func (l *Logger) FatalTf(tag, format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, FatalLevel, tag, format, a...)
 }

 func (l *Logger) VLogTf(verbosity uint8, tag, format string, a ...interface{}) error {
 	return l.logf(DefaultCallDepth, severityFromVerbosity(verbosity), tag, format, a...)
 }

 var defaultLogger = &Logger{
 	level: int32(InfoLevel),
 	options: logOptions{
 		MinSeverityForFileAndLineInfo: ErrorLevel,
 		Writer:                        os.Stderr,
 	},
 	pid: uint64(os.Getpid()),
 }

 func Logf(callDepth int, logLevel LogLevel, tag string, format string, a ...interface{}) error {
 	if l := GetDefaultLogger(); l != nil {
 		return l.logf(callDepth+1, logLevel, tag, format, a...)
 	}
 	return errors.New("default logger not initialized")
 }

 func GetDefaultLogger() *Logger {
 	return defaultLogger
 }

 func SetDefaultLogger(l *Logger) {
 	defaultLogger = l
 }

 func SetSeverity(logLevel LogLevel) {
 	if l := GetDefaultLogger(); l != nil {
 		atomic.StoreInt32(&l.level, int32(logLevel))
 	}
 }

 func SetVerbosity(verbosity uint8) {
 	SetSeverity(severityFromVerbosity(verbosity))
 }

 func Tracef(format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, TraceLevel, "", format, a...)
 }

 func Debugf(format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, DebugLevel, "", format, a...)
 }

 func Infof(format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, InfoLevel, "", format, a...)
 }

 func Warnf(format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, WarningLevel, "", format, a...)
 }

 func Errorf(format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, ErrorLevel, "", format, a...)
 }

 func Fatalf(format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, FatalLevel, "", format, a...)
 }

 func VLogf(verbosity uint8, format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, severityFromVerbosity(verbosity), "", format, a...)
 }

 func TraceTf(tag, format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, TraceLevel, tag, format, a...)
 }

 func DebugTf(tag, format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, DebugLevel, tag, format, a...)
 }

 func InfoTf(tag, format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, InfoLevel, tag, format, a...)
 }

 func WarnTf(tag, format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, WarningLevel, tag, format, a...)
 }

 func ErrorTf(tag, format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, ErrorLevel, tag, format, a...)
 }

 func FatalTf(tag, format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, FatalLevel, tag, format, a...)
 }

 func VLogTf(verbosity uint8, tag, format string, a ...interface{}) error {
 	return Logf(DefaultCallDepth, severityFromVerbosity(verbosity), tag, format, a...)
 }
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	//go:build !build_with_native_toolchain

	package syslog

	import (
	"context"
	"encoding/binary"
	"errors"
	"flag"
	"fmt"
	"io"
	"math"
	"os"
	"runtime"
	"strconv"
	"strings"
	"sync/atomic"
	"syscall/zx"
	"unicode/utf8"

	"fidl/fuchsia/diagnostics"
	"fidl/fuchsia/logger"
	)

	// ErrMsgTooLong is returned when a message is truncated.
	type ErrMsgTooLong struct {
	// Msg is the truncated part of the message.
	Msg string
	}

	func (e *ErrMsgTooLong) Error() string {
	return "too long message was truncated"
	}

	const (
	_ uint8 = iota
	DebugVerbosity
	TraceVerbosity
	)

	type LogLevel int8

	const (
	TraceLevel = LogLevel(logger.LogLevelFilterTrace)
	DebugLevel = LogLevel(logger.LogLevelFilterDebug)
	InfoLevel = LogLevel(logger.LogLevelFilterInfo)
	WarningLevel = LogLevel(logger.LogLevelFilterWarn)
	ErrorLevel = LogLevel(logger.LogLevelFilterError)
	FatalLevel = LogLevel(logger.LogLevelFilterFatal)
	NoneLevel = LogLevel(logger.LogLevelFilterNone)
	)

	var _ flag.Value = (*LogLevel)(nil)

	// Set implements the flag.Value interface.
	func (ll *LogLevel) Set(s string) error {
	s = strings.ToUpper(s)
	lls := logLevelFromString(s)
	if lls != NoneLevel {
	*ll = lls
	return nil
	}
	v, err := strconv.Atoi(s)
	if err != nil {
	return err
	}
	*ll = LogLevel(v)
	return nil
	}

	func logLevelFromString(s string) LogLevel {
	switch s {
	case "ALL":
	return math.MinInt8
	case "TRACE":
	return TraceLevel
	case "DEBUG":
	return DebugLevel
	case "INFO":
	return InfoLevel
	case "WARNING":
	return WarningLevel
	case "ERROR":
	return ErrorLevel
	case "FATAL":
	return FatalLevel
	default:
	return NoneLevel
	}
	}

	func (ll LogLevel) String() string {
	switch ll {
	case math.MinInt8:
	return "ALL"
	case TraceLevel:
	return "TRACE"
	case DebugLevel:
	return "DEBUG"
	case InfoLevel:
	return "INFO"
	case WarningLevel:
	return "WARNING"
	case ErrorLevel:
	return "ERROR"
	case FatalLevel:
	return "FATAL"
	default:
	return fmt.Sprintf("LOG(%d)", ll)
	}
	}

	type Writer struct {
	*Logger
	}

	func (l *Writer) Write(data []byte) (n int, err error) {
	origLen := len(data)

	// Strip out the trailing newline the `log` library adds because the
	// logging service also adds a trailing newline.
	if len(data) > 0 && data[len(data)-1] == '\n' {
	data = data[:len(data)-1]
	}

	if err := l.Infof("%s", data); err != nil {
	return 0, err
	}

	return origLen, nil
	}

	type logOptions struct {
	LogSink *logger.LogSinkWithCtxInterface
	MinSeverityForFileAndLineInfo LogLevel
	Tags []string
	Writer io.Writer
	}

	type LogInitOptions struct {
	logOptions
	LogLevel LogLevel
	}

	type Logger struct {
	socket zx.Socket
	cancel context.CancelFunc

	droppedLogs uint32
	options logOptions
	level int32 // LogLevel; accessed atomically.
	pid uint64
	}

	func NewLogger(options LogInitOptions) (*Logger, error) {
	if l, max := len(options.Tags), int(logger.MaxTags); l > max {
	return nil, fmt.Errorf("too many tags: %d/%d", l, max)
	}
	for _, tag := range options.Tags {
	if l, max := len(tag), int(logger.MaxTagLenBytes); l > max {
	return nil, fmt.Errorf("tag too long: %d/%d", l, max)
	}
	}
	l := Logger{
	options: options.logOptions,
	level: int32(options.LogLevel),
	pid: uint64(os.Getpid()),
	}
	if logSink := options.LogSink; logSink != nil {
	const tag = "syslog"
	ctx, cancel := context.WithCancel(context.Background())
	l.cancel = func() {
	cancel()
	if err := logSink.Close(); err != nil {
	_ = l.WarnTf(tag, "fuchsia.logger/LogSink.Close(): %s", err)
	}
	}

	localS, peerS, err := zx.NewSocket(zx.SocketDatagram)
	if err != nil {
	_ = l.Close()
	return nil, err
	}
	l.socket = localS
	if err := logSink.Connect(context.Background(), peerS); err != nil {
	_ = l.Close()
	return nil, err
	}

	initLevel := options.LogLevel
	go func() {
	for {
	_ = l.InfoTf(tag, "calling fuchsia.logger/LogSink.WaitForInterestChange...")
	interest, err := logSink.WaitForInterestChange(ctx)
	if err != nil {
	func() {
	switch err := err.(type) {
	case *zx.Error:
	switch err.Status {
	case zx.ErrBadHandle, zx.ErrCanceled, zx.ErrPeerClosed:
	return
	}
	_ = l.WarnTf(tag, "fuchsia.logger/LogSink.WaitForInterestChange(): %s", err)
	}
	}()
	return
	}
	switch interest.Which() {
	case logger.LogSinkWaitForInterestChangeResultResponse:
	if interest.Response.Data.HasMinSeverity() {
	minSeverity := interest.Response.Data.GetMinSeverity()
	l.SetSeverity(minSeverity)
	_ = l.InfoTf(tag, "fuchsia.logger/LogSink.WaitForInterestChange({MinSeverity: %s})", minSeverity)
	} else {
	_ = l.InfoTf(tag, "fuchsia.logger/LogSink.WaitForInterestChange({})")
	l.SetSeverity(diagnostics.Severity(initLevel))
	}
	case logger.LogSinkWaitForInterestChangeResultErr:
	_ = l.ErrorTf(tag, "fuchsia.logger/LogSink.WaitForInterestChange(): %s", interest.Err)
	return
	}
	}
	}()
	}
	return &l, nil
	}

	func NewLoggerWithDefaults(tags ...string) (*Logger, error) {
	options := LogInitOptions{
	LogLevel: InfoLevel,
	}
	options.MinSeverityForFileAndLineInfo = ErrorLevel
	options.Tags = tags
	return NewLogger(options)
	}

	func (l *Logger) Close() error {
	l.cancel()
	return l.socket.Close()
	}

	func (l *Logger) logToWriter(writer io.Writer, time zx.Time, logLevel LogLevel, tag, msg string) error {
	if writer == nil {
	writer = os.Stderr
	}
	var tagsStorage [logger.MaxTags + 1]string
	tags := tagsStorage[:0]
	for _, tag := range l.options.Tags {
	if len(tag) > 0 {
	tags = append(tags, tag)
	}
	}
	if len(tag) > 0 {
	tags = append(tags, tag)
	}
	var buffer [int(logger.MaxTags+1) * int(logger.MaxTagLenBytes)]byte
	pos := 0
	for i, tag := range tags {
	if i > 0 {
	pos += copy(buffer[pos:], ", ")
	}
	pos += copy(buffer[pos:], tag)
	}
	_, err := fmt.Fprintf(writer, "[%05d.%06d][%d][0][%s] %s: %s\n", time/1000000000, (time/1000)%1000000, l.pid, buffer[:pos], logLevel, msg)
	return err
	}

	func (l *Logger) logToSocket(time zx.Time, logLevel LogLevel, tag, msg string) error {
	const golangThreadID = 0

	var buffer [logger.MaxDatagramLenBytes]byte

	pos := 0
	for _, i := range [...]uint64{
	l.pid,
	golangThreadID,
	uint64(time),
	} {
	binary.LittleEndian.PutUint64(buffer[pos:], i)
	pos += 8
	}
	for _, i := range [...]uint32{
	uint32(logLevel),
	atomic.LoadUint32(&l.droppedLogs),
	} {
	binary.LittleEndian.PutUint32(buffer[pos:], i)
	pos += 4
	}

	// Write global tags
	for _, tag := range l.options.Tags {
	if length := len(tag); length != 0 {
	buffer[pos] = byte(length)
	pos += 1
	pos += copy(buffer[pos:], tag)
	}
	}

	// Write local tags
	if length := len(tag); length != 0 {
	buffer[pos] = byte(length)
	pos += 1
	pos += copy(buffer[pos:], tag)
	}

	const ellipsis = "..."

	// Write msg
	buffer[pos] = 0
	pos += 1

	payload := msg
	if len(payload)+1 > len(buffer)-pos {
	payload = payload[:len(buffer)-pos-1-len(ellipsis)]

	// Remove the last byte until the result is valid UTF-8.
	for {
	if lastRune, _ := utf8.DecodeLastRuneInString(payload); lastRune != utf8.RuneError {
	break
	}
	payload = payload[:len(payload)-1]
	}
	}
	pos += copy(buffer[pos:], payload)
	if payload != msg {
	pos += copy(buffer[pos:], ellipsis)
	}

	buffer[pos] = 0
	pos += 1

	if _, err := l.socket.Write(buffer[:pos], 0); err != nil {
	atomic.AddUint32(&l.droppedLogs, 1)
	return err
	}

	if payload != msg {
	return &ErrMsgTooLong{Msg: msg[len(payload):]}
	}
	return nil
	}

	func (l *Logger) logf(callDepth int, logLevel LogLevel, tag string, format string, a ...interface{}) error {
	if LogLevel(atomic.LoadInt32(&l.level)) > logLevel {
	return nil
	}
	time := zx.Sys_clock_get_monotonic()
	msg := fmt.Sprintf(format, a...)
	if logLevel >= l.options.MinSeverityForFileAndLineInfo {
	_, file, line, ok := runtime.Caller(callDepth)
	if !ok {
	file = "???"
	line = 0
	} else {
	short := file
	for i := len(file) - 1; i > 0; i-- {
	if file[i] == '/' {
	short = file[i+1:]
	break
	}
	}
	file = short
	}
	msg = fmt.Sprintf("%s(%d): %s ", file, line, msg)
	}
	if len(tag) > int(logger.MaxTagLenBytes) {
	tag = tag[:logger.MaxTagLenBytes]
	}
	if logLevel == FatalLevel {
	defer os.Exit(1)
	}
	if atomic.LoadUint32((*uint32)(&l.socket)) != uint32(zx.HandleInvalid) {
	switch err := l.logToSocket(time, logLevel, tag, msg).(type) {
	case *zx.Error:
	switch err.Status {
	case zx.ErrPeerClosed, zx.ErrBadState:
	atomic.StoreUint32((*uint32)(&l.socket), uint32(zx.HandleInvalid))
	default:
	return err
	}
	default:
	return err
	}
	}
	return l.logToWriter(l.options.Writer, time, logLevel, tag, msg)
	}

	func (l *Logger) SetSeverity(severity diagnostics.Severity) {
	atomic.StoreInt32(&l.level, int32(severity))
	}

	// severityFromVerbosity provides the severity corresponding to the given
	// verbosity. Note that verbosity relative to the default severity and can
	// be thought of as incrementally "more vebose than" the baseline.
	func severityFromVerbosity(verbosity uint8) LogLevel {
	level := InfoLevel - LogLevel(verbosity*logger.LogVerbosityStepSize)
	// verbosity scale sits in the interstitial space between INFO and DEBUG
	if level < (DebugLevel + 1) {
	return DebugLevel + 1
	}
	return level
	}

	func (l *Logger) SetVerbosity(verbosity uint8) {
	atomic.StoreInt32(&l.level, int32(severityFromVerbosity(verbosity)))
	}

	const DefaultCallDepth = 2

	func (l *Logger) Tracef(format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, TraceLevel, "", format, a...)
	}

	func (l *Logger) Debugf(format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, DebugLevel, "", format, a...)
	}

	func (l *Logger) Infof(format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, InfoLevel, "", format, a...)
	}

	func (l *Logger) Warnf(format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, WarningLevel, "", format, a...)
	}

	func (l *Logger) Errorf(format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, ErrorLevel, "", format, a...)
	}

	func (l *Logger) Fatalf(format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, FatalLevel, "", format, a...)
	}

	func (l *Logger) VLogf(verbosity uint8, format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, severityFromVerbosity(verbosity), "", format, a...)
	}

	func (l *Logger) TraceTf(tag, format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, TraceLevel, tag, format, a...)
	}

	func (l *Logger) DebugTf(tag, format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, DebugLevel, tag, format, a...)
	}

	func (l *Logger) InfoTf(tag, format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, InfoLevel, tag, format, a...)
	}

	func (l *Logger) WarnTf(tag, format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, WarningLevel, tag, format, a...)
	}

	func (l *Logger) ErrorTf(tag, format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, ErrorLevel, tag, format, a...)
	}

	func (l *Logger) FatalTf(tag, format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, FatalLevel, tag, format, a...)
	}

	func (l *Logger) VLogTf(verbosity uint8, tag, format string, a ...interface{}) error {
	return l.logf(DefaultCallDepth, severityFromVerbosity(verbosity), tag, format, a...)
	}

	var defaultLogger = &Logger{
	level: int32(InfoLevel),
	options: logOptions{
	MinSeverityForFileAndLineInfo: ErrorLevel,
	Writer: os.Stderr,
	},
	pid: uint64(os.Getpid()),
	}

	func Logf(callDepth int, logLevel LogLevel, tag string, format string, a ...interface{}) error {
	if l := GetDefaultLogger(); l != nil {
	return l.logf(callDepth+1, logLevel, tag, format, a...)
	}
	return errors.New("default logger not initialized")
	}

	func GetDefaultLogger() *Logger {
	return defaultLogger
	}

	func SetDefaultLogger(l *Logger) {
	defaultLogger = l
	}

	func SetSeverity(logLevel LogLevel) {
	if l := GetDefaultLogger(); l != nil {
	atomic.StoreInt32(&l.level, int32(logLevel))
	}
	}

	func SetVerbosity(verbosity uint8) {
	SetSeverity(severityFromVerbosity(verbosity))
	}

	func Tracef(format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, TraceLevel, "", format, a...)
	}

	func Debugf(format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, DebugLevel, "", format, a...)
	}

	func Infof(format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, InfoLevel, "", format, a...)
	}

	func Warnf(format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, WarningLevel, "", format, a...)
	}

	func Errorf(format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, ErrorLevel, "", format, a...)
	}

	func Fatalf(format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, FatalLevel, "", format, a...)
	}

	func VLogf(verbosity uint8, format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, severityFromVerbosity(verbosity), "", format, a...)
	}

	func TraceTf(tag, format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, TraceLevel, tag, format, a...)
	}

	func DebugTf(tag, format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, DebugLevel, tag, format, a...)
	}

	func InfoTf(tag, format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, InfoLevel, tag, format, a...)
	}

	func WarnTf(tag, format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, WarningLevel, tag, format, a...)
	}

	func ErrorTf(tag, format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, ErrorLevel, tag, format, a...)
	}

	func FatalTf(tag, format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, FatalLevel, tag, format, a...)
	}

	func VLogTf(verbosity uint8, tag, format string, a ...interface{}) error {
	return Logf(DefaultCallDepth, severityFromVerbosity(verbosity), tag, format, a...)
	}