// NewWithCallDepth creates a new Standard logger for module, and when
// printing file names and line numbers, it goes extraCallDepth up the
// stack from where logger was invoked.
func NewWithCallDepth(module string, extraCallDepth int, iow io.Writer) *Standard {
log := logging.MustGetLogger(module)
log.ExtraCalldepth = 1 + extraCallDepth
// If iow's implementation has an Fd() method, call it and
// check if the underlying file descriptor is a terminal.
isTerminal := false
if fdOwner, ok := iow.(interface {
Fd() uintptr
}); ok {
isTerminal = isatty.IsTerminal(fdOwner.Fd())
}
ret := &Standard{
internal: log,
module: module,
externalLoggers: make(map[uint64]ExternalLogger),
externalLoggersCount: 0,
externalLogLevel: keybase1.LogLevel_INFO,
isTerminal: isTerminal,
buffer: make(chan *entry, 10000),
drop: make(chan bool, 1),
}
ret.initLogging(iow)
go ret.processBuffer()
return ret
}
func pullImage(
ctx context.Context, l *LocalCluster, ref string, options types.ImagePullOptions,
) error {
// HACK: on CircleCI, docker pulls the image on the first access from an
// acceptance test even though that image is already present. So we first
// check to see if our image is present in order to avoid this slowness.
if hasImage(ctx, l, ref) {
log.Infof(ctx, "ImagePull %s already exists", ref)
return nil
}
log.Infof(ctx, "ImagePull %s starting", ref)
defer log.Infof(ctx, "ImagePull %s complete", ref)
rc, err := l.client.ImagePull(ctx, ref, options)
if err != nil {
return err
}
defer rc.Close()
out := os.Stderr
outFd := out.Fd()
isTerminal := isatty.IsTerminal(outFd)
return jsonmessage.DisplayJSONMessagesStream(rc, out, outFd, isTerminal, nil)
}
func (cmd) Execute(arguments map[string]interface{}) bool {
URL := arguments["<URL>"].(string)
command := arguments["<command>"].([]string)
tty := isatty.IsTerminal(os.Stdout.Fd())
// Parse URL
u, err := url.Parse(URL)
if err != nil {
fmt.Println("Failed to parse URL, error: ", err)
return false
}
qs := u.Query()
// Set the command, if we have one
if len(command) > 0 {
qs["command"] = command
}
// Set tty=true if we're in a tty
if tty {
qs.Set("tty", "true")
}
// Update query string
u.RawQuery = qs.Encode()
// Connect to remove websocket
ws, res, err := dialer.Dial(u.String(), nil)
if err == websocket.ErrBadHandshake {
fmt.Println("Failed to connect, status: ", res.StatusCode)
return false
}
if err != nil {
fmt.Println("Failed to connect, error: ", err)
return false
}
// Create shell client
shell := shellclient.New(ws)
// Switch terminal to raw mode
cleanup := func() {}
if tty {
cleanup = SetupRawTerminal(shell.SetSize)
}
// Connect pipes
go ioext.CopyAndClose(shell.StdinPipe(), os.Stdin)
go io.Copy(os.Stdout, shell.StdoutPipe())
go io.Copy(os.Stderr, shell.StderrPipe())
// Wait for shell to be done
success, _ := shell.Wait()
// If we were in a tty we let's restore state
cleanup()
return success
}
func init() {
ColorScheme = c.Colorize{
Colors: map[string]string{
"DEFAULT": c.DefaultColors["default"],
"FILENAME": c.DefaultColors["light_green"],
"META": c.DefaultColors["red"],
"DESCRIPTION": c.DefaultColors["light_yellow"],
"HR": c.DefaultColors["light_cyan"],
"NUMBER": c.DefaultColors["light_red"],
},
Reset: true,
Disable: !isatty.IsTerminal(os.Stdout.Fd()),
}
BlankScheme = ColorScheme
BlankScheme.Disable = true
}
// NewWithCallDepth creates a new Standard logger for module, and when
// printing file names and line numbers, it goes extraCallDepth up the
// stack from where logger was invoked.
func NewWithCallDepth(module string, extraCallDepth int, iow io.Writer) *Standard {
log := logging.MustGetLogger(module)
log.ExtraCalldepth = 1 + extraCallDepth
// If iow's implementation has an Fd() method, call it and
// check if the underlying file descriptor is a terminal.
isTerminal := false
if fdOwner, ok := iow.(interface {
Fd() uintptr
}); ok {
isTerminal = isatty.IsTerminal(fdOwner.Fd())
}
ret := &Standard{
internal: log,
module: module,
isTerminal: isTerminal,
}
ret.initLogging(iow)
return ret
}
isatty "github.com/mattn/go-isatty"
)
const escape = "\x1b"
// Foreground text colors
const (
fgRed = "31"
fgGreen = "32"
fgYellow = "33"
fgBlue = "34"
fgMagenta = "35"
fgCyan = "36"
)
var noColor = !isatty.IsTerminal(os.Stdout.Fd())
func colorize(code, text string) string {
if !noColor {
return format(code) + text + unformat()
}
return text
}
func format(code string) string {
return escape + "[" + code + "m"
}
func unformat() string {
return escape + "[0m"
}
package logger
import (
"os"
"sync"
logging "github.com/keybase/go-logging"
isatty "github.com/mattn/go-isatty"
)
var globalLock sync.Mutex
var stderrIsTerminal = isatty.IsTerminal(os.Stderr.Fd())
var currentLogFileWriter *logFileWriter
func init() {
logBackend := logging.NewLogBackend(ErrorWriter(), "", 0)
logging.SetBackend(logBackend)
}
func stdinIsatty() bool {
return isatty.IsTerminal(os.Stdin.Fd())
}
// LoggerWithConfig returns a Logger middleware with config.
// See: `Logger()`.
func LoggerWithConfig(config LoggerConfig) echo.MiddlewareFunc {
// Defaults
if config.Skipper == nil {
config.Skipper = DefaultLoggerConfig.Skipper
}
if config.Format == "" {
config.Format = DefaultLoggerConfig.Format
}
if config.Output == nil {
config.Output = DefaultLoggerConfig.Output
}
config.template = fasttemplate.New(config.Format, "${", "}")
config.color = color.New()
if w, ok := config.Output.(*os.File); !ok || !isatty.IsTerminal(w.Fd()) {
config.color.Disable()
}
config.pool = sync.Pool{
New: func() interface{} {
return bytes.NewBuffer(make([]byte, 256))
},
}
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) (err error) {
if config.Skipper(c) {
return next(c)
}
req := c.Request()
res := c.Response()
start := time.Now()
if err = next(c); err != nil {
c.Error(err)
}
stop := time.Now()
buf := config.pool.Get().(*bytes.Buffer)
buf.Reset()
defer config.pool.Put(buf)
_, err = config.template.ExecuteFunc(buf, func(w io.Writer, tag string) (int, error) {
switch tag {
case "time_rfc3339":
return w.Write([]byte(time.Now().Format(time.RFC3339)))
case "remote_ip":
ra := c.RealIP()
return w.Write([]byte(ra))
case "host":
return w.Write([]byte(req.Host))
case "uri":
return w.Write([]byte(req.RequestURI))
case "method":
return w.Write([]byte(req.Method))
case "path":
p := req.URL.Path
if p == "" {
p = "/"
}
return w.Write([]byte(p))
case "referer":
return w.Write([]byte(req.Referer()))
case "user_agent":
return w.Write([]byte(req.UserAgent()))
case "status":
n := res.Status
s := config.color.Green(n)
switch {
case n >= 500:
s = config.color.Red(n)
case n >= 400:
s = config.color.Yellow(n)
case n >= 300:
s = config.color.Cyan(n)
}
return w.Write([]byte(s))
case "latency":
l := stop.Sub(start).Nanoseconds() / 1000
return w.Write([]byte(strconv.FormatInt(l, 10)))
case "latency_human":
return w.Write([]byte(stop.Sub(start).String()))
case "bytes_in":
b := req.Header.Get(echo.HeaderContentLength)
if b == "" {
b = "0"
}
return w.Write([]byte(b))
case "bytes_out":
return w.Write([]byte(strconv.FormatInt(res.Size, 10)))
default:
switch {
case strings.HasPrefix(tag, "header:"):
return buf.Write([]byte(c.Request().Header.Get(tag[7:])))
case strings.HasPrefix(tag, "query:"):
return buf.Write([]byte(c.QueryParam(tag[6:])))
case strings.HasPrefix(tag, "form:"):
return buf.Write([]byte(c.FormValue(tag[5:])))
}
}
return 0, nil
})
if err == nil {
config.Output.Write(buf.Bytes())
}
return
}
}
}
// LoggerWithConfig returns a logger middleware from config.
// See: `Logger()`.
func LoggerWithConfig(config LoggerConfig) echo.MiddlewareFunc {
// Defaults
if config.Format == "" {
config.Format = DefaultLoggerConfig.Format
}
if config.Output == nil {
config.Output = DefaultLoggerConfig.Output
}
config.template = fasttemplate.New(config.Format, "${", "}")
config.color = color.New()
if w, ok := config.Output.(*os.File); !ok || !isatty.IsTerminal(w.Fd()) {
config.color.Disable()
}
config.bufferPool = sync.Pool{
New: func() interface{} {
return bytes.NewBuffer(make([]byte, 256))
},
}
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) (err error) {
req := c.Request()
res := c.Response()
start := time.Now()
if err = next(c); err != nil {
c.Error(err)
}
stop := time.Now()
buf := config.bufferPool.Get().(*bytes.Buffer)
buf.Reset()
defer config.bufferPool.Put(buf)
_, err = config.template.ExecuteFunc(buf, func(w io.Writer, tag string) (int, error) {
switch tag {
case "time_rfc3339":
return w.Write([]byte(time.Now().Format(time.RFC3339)))
case "remote_ip":
ra := req.RemoteAddress()
if ip := req.Header().Get(echo.HeaderXRealIP); ip != "" {
ra = ip
} else if ip = req.Header().Get(echo.HeaderXForwardedFor); ip != "" {
ra = ip
} else {
ra, _, _ = net.SplitHostPort(ra)
}
return w.Write([]byte(ra))
case "host":
return w.Write([]byte(req.Host()))
case "uri":
return w.Write([]byte(req.URI()))
case "method":
return w.Write([]byte(req.Method()))
case "path":
p := req.URL().Path()
if p == "" {
p = "/"
}
return w.Write([]byte(p))
case "referer":
return w.Write([]byte(req.Referer()))
case "user_agent":
return w.Write([]byte(req.UserAgent()))
case "status":
n := res.Status()
s := config.color.Green(n)
switch {
case n >= 500:
s = config.color.Red(n)
case n >= 400:
s = config.color.Yellow(n)
case n >= 300:
s = config.color.Cyan(n)
}
return w.Write([]byte(s))
case "latency":
l := stop.Sub(start).Nanoseconds() / 1000
return w.Write([]byte(strconv.FormatInt(l, 10)))
case "latency_human":
return w.Write([]byte(stop.Sub(start).String()))
case "rx_bytes":
b := req.Header().Get(echo.HeaderContentLength)
if b == "" {
b = "0"
}
return w.Write([]byte(b))
case "tx_bytes":
return w.Write([]byte(strconv.FormatInt(res.Size(), 10)))
default:
return w.Write([]byte(fmt.Sprintf("[unknown tag %s]", tag)))
}
})
if err == nil {
config.Output.Write(buf.Bytes())
}
return
}
}
}
func IsStdoutTty() bool {
return goisatty.IsTerminal(os.Stdout.Fd())
}
// LoggerWithConfig returns a logger middleware from config.
// See `Logger()`.
func LoggerWithConfig(config LoggerConfig) echo.MiddlewareFunc {
// Defaults
if config.Format == "" {
config.Format = DefaultLoggerConfig.Format
}
if config.Output == nil {
config.Output = DefaultLoggerConfig.Output
}
config.template = fasttemplate.New(config.Format, "${", "}")
config.color = color.New()
if w, ok := config.Output.(*os.File); !ok || !isatty.IsTerminal(w.Fd()) {
config.color.Disable()
}
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) (err error) {
rq := c.Request()
rs := c.Response()
start := time.Now()
if err = next(c); err != nil {
c.Error(err)
}
stop := time.Now()
_, err = config.template.ExecuteFunc(config.Output, func(w io.Writer, tag string) (int, error) {
switch tag {
case "time_rfc3339":
return w.Write([]byte(time.Now().Format(time.RFC3339)))
case "remote_ip":
ra := rq.RemoteAddress()
if ip := rq.Header().Get(echo.HeaderXRealIP); ip != "" {
ra = ip
} else if ip = rq.Header().Get(echo.HeaderXForwardedFor); ip != "" {
ra = ip
} else {
ra, _, _ = net.SplitHostPort(ra)
}
return w.Write([]byte(ra))
case "uri":
return w.Write([]byte(rq.URI()))
case "method":
return w.Write([]byte(rq.Method()))
case "path":
p := rq.URL().Path()
if p == "" {
p = "/"
}
return w.Write([]byte(p))
case "status":
n := rs.Status()
s := config.color.Green(n)
switch {
case n >= 500:
s = config.color.Red(n)
case n >= 400:
s = config.color.Yellow(n)
case n >= 300:
s = config.color.Cyan(n)
}
return w.Write([]byte(s))
case "response_time":
return w.Write([]byte(stop.Sub(start).String()))
case "response_size":
return w.Write([]byte(strconv.FormatInt(rs.Size(), 10)))
default:
return w.Write([]byte(fmt.Sprintf("[unknown tag %s]", tag)))
}
})
return
}
}
}
func main() {
var (
ungronFlag bool
monochromeFlag bool
streamFlag bool
noSortFlag bool
versionFlag bool
)
flag.BoolVar(&ungronFlag, "ungron", false, "")
flag.BoolVar(&ungronFlag, "u", false, "")
flag.BoolVar(&monochromeFlag, "monochrome", false, "")
flag.BoolVar(&monochromeFlag, "m", false, "")
flag.BoolVar(&streamFlag, "s", false, "")
flag.BoolVar(&streamFlag, "stream", false, "")
flag.BoolVar(&noSortFlag, "no-sort", false, "")
flag.BoolVar(&versionFlag, "version", false, "")
flag.Parse()
// Print version information
if versionFlag {
fmt.Printf("gron version %s\n", gronVersion)
os.Exit(exitOK)
}
// Determine what the program's input should be:
// file, HTTP URL or stdin
var rawInput io.Reader
filename := flag.Arg(0)
if filename == "" || filename == "-" {
rawInput = os.Stdin
} else {
if !validURL(filename) {
r, err := os.Open(filename)
if err != nil {
fatal(exitOpenFile, err)
}
rawInput = r
} else {
r, err := getURL(filename)
if err != nil {
fatal(exitFetchURL, err)
}
rawInput = r
}
}
var opts int
// The monochrome option should be forced if the output isn't a terminal
// to avoid doing unnecessary work calling the color functions
if monochromeFlag || !isatty.IsTerminal(os.Stdout.Fd()) {
opts = opts | optMonochrome
}
if noSortFlag {
opts = opts | optNoSort
}
// Pick the appropriate action: gron, ungron or gronStream
var a actionFn = gron
if ungronFlag {
a = ungron
} else if streamFlag {
a = gronStream
}
exitCode, err := a(rawInput, os.Stdout, opts)
if exitCode != exitOK {
fatal(exitCode, err)
}
os.Exit(exitOK)
}