log

Documentation

Overview

Package log contains logging related functionality

Index

• func Askf(format string, a ...interface{})
• func Error(a ...interface{})
• func Errorf(format string, a ...interface{})
• func GetStderr() io.Writer
• func GetStdout() io.Writer
• func Info(a ...interface{})
• func Infof(format string, a ...interface{})
• func IsDebug() bool
• func IsJSON() bool
• func IsTerminal(w io.Writer) bool
• func Italic(a ...interface{})
• func Namef(format string, a ...interface{})
• func Progressf(format string, a ...interface{})
• func Success(a ...interface{})
• func Successf(format string, a ...interface{})
• func Warning(a ...interface{})
• func Warningf(format string, a ...interface{})
• type Status
  • func NewStatus(w io.Writer) *Status
  • func Spinner(status string) *Status
  • func SpinnerNoSpin(status string) *Status
  • func Spinnerf(format string, a ...interface{}) *Status
  • func (s *Status) End(success bool)
  • func (s *Status) MaybeWrapWriter(w io.Writer) io.Writer
  • func (s *Status) Start(status string, debug bool)
  • func (s *Status) WrapWriter(w io.Writer) io.Writer
• type StatusFriendlyWriter
  • func (ww *StatusFriendlyWriter) Write(p []byte) (n int, err error)

Functions

func Askf

func Askf(format string, a ...interface{})

Askf will print out information, but in an "Ask" way (without newline)

func Error

func Error(a ...interface{})

Error will output in an appropriate "progress" manner

func Errorf

func Errorf(format string, a ...interface{})

Errorf will output in an appropriate "progress" manner

func GetStderr

func GetStderr() io.Writer

GetStderr gets the appropriate stderrfrom the OS. If it's Linux, it will use the go-colorable library in order to fix any and all color ASCII issues. TODO: Test needs to be added once we get Windows testing available on TravisCI / CI platform.

func GetStdout

func GetStdout() io.Writer

GetStdout gets the appropriate stdout from the OS. If it's Linux, it will use the go-colorable library in order to fix any and all color ASCII issues. TODO: Test needs to be added once we get Windows testing available on TravisCI / CI platform.

func Info

func Info(a ...interface{})

Info will simply print out information on a new (bolded) line this is intended as information *after* something has been deployed

func Infof

func Infof(format string, a ...interface{})

Infof will simply print out information on a new (bolded) line this is intended as information *after* something has been deployed

func IsDebug

func IsDebug() bool

IsDebug returns true if we are debugging (-v is set to anything but 0)

func IsJSON

func IsJSON() bool

IsJSON returns true if we are in machine output mode.. under NO circumstances should we output any logging.. as we are only outputting json

func IsTerminal

func IsTerminal(w io.Writer) bool

IsTerminal returns true if the writer w is a terminal This function is modified if we are running within Windows.. as Golang's built-in "IsTerminal" command only works on UNIX-based systems: https://github.com/golang/crypto/blob/master/ssh/terminal/util.go#L5

func Italic

func Italic(a ...interface{})

Italic will simply print out information on a new italic line

func Namef

func Namef(format string, a ...interface{})

Namef will output the name of the component / application / project in a *bolded* manner

func Progressf

func Progressf(format string, a ...interface{})

Progressf will output in an appropriate "progress" manner

func Success

func Success(a ...interface{})

Success will output in an appropriate "success" manner

func Successf

func Successf(format string, a ...interface{})

Successf will output in an appropriate "progress" manner

func Warning

func Warning(a ...interface{})

Warning will output in an appropriate "progress" manner

func Warningf

func Warningf(format string, a ...interface{})

Warningf will output in an appropriate "progress" manner

Types

type Status

type Status struct {
	// contains filtered or unexported fields
}

Status is used to track ongoing status in a CLI, with a nice loading spinner when attached to a terminal

func NewStatus

func NewStatus(w io.Writer) *Status

NewStatus creates a new default Status

func Spinner

func Spinner(status string) *Status

Spinner creates a spinner, sets the prefix then returns it. Remember to use .End(bool) to stop the spin / when you're done. For example: defer s.End(false)

func SpinnerNoSpin

func SpinnerNoSpin(status string) *Status

SpinnerNoSpin is the same as the "Spinner" function but forces no spinning

func Spinnerf

func Spinnerf(format string, a ...interface{}) *Status

Spinnerf creates a spinner, sets the prefix then returns it. Remember to use .End(bool) to stop the spin / when you're done. For example: defer s.End(false) for situations where spinning isn't viable (debug)

func (*Status) End

func (s *Status) End(success bool)

End completes the current status, ending any previous spinning and marking the status as success or failure

func (*Status) MaybeWrapWriter

func (s *Status) MaybeWrapWriter(w io.Writer) io.Writer

MaybeWrapWriter returns a StatusFriendlyWriter for w IFF w and spinner's output are a terminal, otherwise it returns w

func (*Status) Start

func (s *Status) Start(status string, debug bool)

Start starts a new phase of the status, if attached to a terminal there will be a loading spinner with this status

func (*Status) WrapWriter

func (s *Status) WrapWriter(w io.Writer) io.Writer

WrapWriter returns a StatusFriendlyWriter for w

type StatusFriendlyWriter

type StatusFriendlyWriter struct {
	// contains filtered or unexported fields
}

StatusFriendlyWriter is used to wrap another Writer to make it toggle the status spinner before and after writes so that they do not collide

func (*StatusFriendlyWriter) Write

func (ww *StatusFriendlyWriter) Write(p []byte) (n int, err error)