vendor/github.com/Azure/go-autorest/logger/logger.go - cloudstack-kubernetes-provider - Git at Google

 package logger

 // Copyright 2017 Microsoft Corporation
 //
 //  Licensed under the Apache License, Version 2.0 (the "License");
 //  you may not use this file except in compliance with the License.
 //  You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 //  Unless required by applicable law or agreed to in writing, software
 //  distributed under the License is distributed on an "AS IS" BASIS,
 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //  See the License for the specific language governing permissions and
 //  limitations under the License.

 import (
 	"bytes"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"net/http"
 	"net/url"
 	"os"
 	"strings"
 	"sync"
 	"time"
 )

 // LevelType tells a logger the minimum level to log. When code reports a log entry,
 // the LogLevel indicates the level of the log entry. The logger only records entries
 // whose level is at least the level it was told to log. See the Log* constants.
 // For example, if a logger is configured with LogError, then LogError, LogPanic,
 // and LogFatal entries will be logged; lower level entries are ignored.
 type LevelType uint32

 const (
 	// LogNone tells a logger not to log any entries passed to it.
 	LogNone LevelType = iota

 	// LogFatal tells a logger to log all LogFatal entries passed to it.
 	LogFatal

 	// LogPanic tells a logger to log all LogPanic and LogFatal entries passed to it.
 	LogPanic

 	// LogError tells a logger to log all LogError, LogPanic and LogFatal entries passed to it.
 	LogError

 	// LogWarning tells a logger to log all LogWarning, LogError, LogPanic and LogFatal entries passed to it.
 	LogWarning

 	// LogInfo tells a logger to log all LogInfo, LogWarning, LogError, LogPanic and LogFatal entries passed to it.
 	LogInfo

 	// LogDebug tells a logger to log all LogDebug, LogInfo, LogWarning, LogError, LogPanic and LogFatal entries passed to it.
 	LogDebug
 )

 const (
 	logNone    = "NONE"
 	logFatal   = "FATAL"
 	logPanic   = "PANIC"
 	logError   = "ERROR"
 	logWarning = "WARNING"
 	logInfo    = "INFO"
 	logDebug   = "DEBUG"
 	logUnknown = "UNKNOWN"
 )

 // ParseLevel converts the specified string into the corresponding LevelType.
 func ParseLevel(s string) (lt LevelType, err error) {
 	switch strings.ToUpper(s) {
 	case logFatal:
 		lt = LogFatal
 	case logPanic:
 		lt = LogPanic
 	case logError:
 		lt = LogError
 	case logWarning:
 		lt = LogWarning
 	case logInfo:
 		lt = LogInfo
 	case logDebug:
 		lt = LogDebug
 	default:
 		err = fmt.Errorf("bad log level '%s'", s)
 	}
 	return
 }

 // String implements the stringer interface for LevelType.
 func (lt LevelType) String() string {
 	switch lt {
 	case LogNone:
 		return logNone
 	case LogFatal:
 		return logFatal
 	case LogPanic:
 		return logPanic
 	case LogError:
 		return logError
 	case LogWarning:
 		return logWarning
 	case LogInfo:
 		return logInfo
 	case LogDebug:
 		return logDebug
 	default:
 		return logUnknown
 	}
 }

 // Filter defines functions for filtering HTTP request/response content.
 type Filter struct {
 	// URL returns a potentially modified string representation of a request URL.
 	URL func(u *url.URL) string

 	// Header returns a potentially modified set of values for the specified key.
 	// To completely exclude the header key/values return false.
 	Header func(key string, val []string) (bool, []string)

 	// Body returns a potentially modified request/response body.
 	Body func(b []byte) []byte
 }

 func (f Filter) processURL(u *url.URL) string {
 	if f.URL == nil {
 		return u.String()
 	}
 	return f.URL(u)
 }

 func (f Filter) processHeader(k string, val []string) (bool, []string) {
 	if f.Header == nil {
 		return true, val
 	}
 	return f.Header(k, val)
 }

 func (f Filter) processBody(b []byte) []byte {
 	if f.Body == nil {
 		return b
 	}
 	return f.Body(b)
 }

 // Writer defines methods for writing to a logging facility.
 type Writer interface {
 	// Writeln writes the specified message with the standard log entry header and new-line character.
 	Writeln(level LevelType, message string)

 	// Writef writes the specified format specifier with the standard log entry header and no new-line character.
 	Writef(level LevelType, format string, a ...interface{})

 	// WriteRequest writes the specified HTTP request to the logger if the log level is greater than
 	// or equal to LogInfo.  The request body, if set, is logged at level LogDebug or higher.
 	// Custom filters can be specified to exclude URL, header, and/or body content from the log.
 	// By default no request content is excluded.
 	WriteRequest(req *http.Request, filter Filter)

 	// WriteResponse writes the specified HTTP response to the logger if the log level is greater than
 	// or equal to LogInfo.  The response body, if set, is logged at level LogDebug or higher.
 	// Custom filters can be specified to exclude URL, header, and/or body content from the log.
 	// By default no response content is excluded.
 	WriteResponse(resp *http.Response, filter Filter)
 }

 // Instance is the default log writer initialized during package init.
 // This can be replaced with a custom implementation as required.
 var Instance Writer

 // default log level
 var logLevel = LogNone

 // Level returns the value specified in AZURE_GO_AUTOREST_LOG_LEVEL.
 // If no value was specified the default value is LogNone.
 // Custom loggers can call this to retrieve the configured log level.
 func Level() LevelType {
 	return logLevel
 }

 func init() {
 	// separated for testing purposes
 	initDefaultLogger()
 }

 func initDefaultLogger() {
 	// init with nilLogger so callers don't have to do a nil check on Default
 	Instance = nilLogger{}
 	llStr := strings.ToLower(os.Getenv("AZURE_GO_SDK_LOG_LEVEL"))
 	if llStr == "" {
 		return
 	}
 	var err error
 	logLevel, err = ParseLevel(llStr)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "go-autorest: failed to parse log level: %s\n", err.Error())
 		return
 	}
 	if logLevel == LogNone {
 		return
 	}
 	// default to stderr
 	dest := os.Stderr
 	lfStr := os.Getenv("AZURE_GO_SDK_LOG_FILE")
 	if strings.EqualFold(lfStr, "stdout") {
 		dest = os.Stdout
 	} else if lfStr != "" {
 		lf, err := os.Create(lfStr)
 		if err == nil {
 			dest = lf
 		} else {
 			fmt.Fprintf(os.Stderr, "go-autorest: failed to create log file, using stderr: %s\n", err.Error())
 		}
 	}
 	Instance = fileLogger{
 		logLevel: logLevel,
 		mu:       &sync.Mutex{},
 		logFile:  dest,
 	}
 }

 // the nil logger does nothing
 type nilLogger struct{}

 func (nilLogger) Writeln(LevelType, string) {}

 func (nilLogger) Writef(LevelType, string, ...interface{}) {}

 func (nilLogger) WriteRequest(*http.Request, Filter) {}

 func (nilLogger) WriteResponse(*http.Response, Filter) {}

 // A File is used instead of a Logger so the stream can be flushed after every write.
 type fileLogger struct {
 	logLevel LevelType
 	mu       *sync.Mutex // for synchronizing writes to logFile
 	logFile  *os.File
 }

 func (fl fileLogger) Writeln(level LevelType, message string) {
 	fl.Writef(level, "%s\n", message)
 }

 func (fl fileLogger) Writef(level LevelType, format string, a ...interface{}) {
 	if fl.logLevel >= level {
 		fl.mu.Lock()
 		defer fl.mu.Unlock()
 		fmt.Fprintf(fl.logFile, "%s %s", entryHeader(level), fmt.Sprintf(format, a...))
 		fl.logFile.Sync()
 	}
 }

 func (fl fileLogger) WriteRequest(req *http.Request, filter Filter) {
 	if req == nil || fl.logLevel < LogInfo {
 		return
 	}
 	b := &bytes.Buffer{}
 	fmt.Fprintf(b, "%s REQUEST: %s %s\n", entryHeader(LogInfo), req.Method, filter.processURL(req.URL))
 	// dump headers
 	for k, v := range req.Header {
 		if ok, mv := filter.processHeader(k, v); ok {
 			fmt.Fprintf(b, "%s: %s\n", k, strings.Join(mv, ","))
 		}
 	}
 	if fl.shouldLogBody(req.Header, req.Body) {
 		// dump body
 		body, err := ioutil.ReadAll(req.Body)
 		if err == nil {
 			fmt.Fprintln(b, string(filter.processBody(body)))
 			if nc, ok := req.Body.(io.Seeker); ok {
 				// rewind to the beginning
 				nc.Seek(0, io.SeekStart)
 			} else {
 				// recreate the body
 				req.Body = ioutil.NopCloser(bytes.NewReader(body))
 			}
 		} else {
 			fmt.Fprintf(b, "failed to read body: %v\n", err)
 		}
 	}
 	fl.mu.Lock()
 	defer fl.mu.Unlock()
 	fmt.Fprint(fl.logFile, b.String())
 	fl.logFile.Sync()
 }

 func (fl fileLogger) WriteResponse(resp *http.Response, filter Filter) {
 	if resp == nil || fl.logLevel < LogInfo {
 		return
 	}
 	b := &bytes.Buffer{}
 	fmt.Fprintf(b, "%s RESPONSE: %d %s\n", entryHeader(LogInfo), resp.StatusCode, filter.processURL(resp.Request.URL))
 	// dump headers
 	for k, v := range resp.Header {
 		if ok, mv := filter.processHeader(k, v); ok {
 			fmt.Fprintf(b, "%s: %s\n", k, strings.Join(mv, ","))
 		}
 	}
 	if fl.shouldLogBody(resp.Header, resp.Body) {
 		// dump body
 		defer resp.Body.Close()
 		body, err := ioutil.ReadAll(resp.Body)
 		if err == nil {
 			fmt.Fprintln(b, string(filter.processBody(body)))
 			resp.Body = ioutil.NopCloser(bytes.NewReader(body))
 		} else {
 			fmt.Fprintf(b, "failed to read body: %v\n", err)
 		}
 	}
 	fl.mu.Lock()
 	defer fl.mu.Unlock()
 	fmt.Fprint(fl.logFile, b.String())
 	fl.logFile.Sync()
 }

 // returns true if the provided body should be included in the log
 func (fl fileLogger) shouldLogBody(header http.Header, body io.ReadCloser) bool {
 	ct := header.Get("Content-Type")
 	return fl.logLevel >= LogDebug && body != nil && !strings.Contains(ct, "application/octet-stream")
 }

 // creates standard header for log entries, it contains a timestamp and the log level
 func entryHeader(level LevelType) string {
 	// this format provides a fixed number of digits so the size of the timestamp is constant
 	return fmt.Sprintf("(%s) %s:", time.Now().Format("2006-01-02T15:04:05.0000000Z07:00"), level.String())
 }
	package logger

	// Copyright 2017 Microsoft Corporation
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"os"
	"strings"
	"sync"
	"time"
	)

	// LevelType tells a logger the minimum level to log. When code reports a log entry,
	// the LogLevel indicates the level of the log entry. The logger only records entries
	// whose level is at least the level it was told to log. See the Log* constants.
	// For example, if a logger is configured with LogError, then LogError, LogPanic,
	// and LogFatal entries will be logged; lower level entries are ignored.
	type LevelType uint32

	const (
	// LogNone tells a logger not to log any entries passed to it.
	LogNone LevelType = iota

	// LogFatal tells a logger to log all LogFatal entries passed to it.
	LogFatal

	// LogPanic tells a logger to log all LogPanic and LogFatal entries passed to it.
	LogPanic

	// LogError tells a logger to log all LogError, LogPanic and LogFatal entries passed to it.
	LogError

	// LogWarning tells a logger to log all LogWarning, LogError, LogPanic and LogFatal entries passed to it.
	LogWarning

	// LogInfo tells a logger to log all LogInfo, LogWarning, LogError, LogPanic and LogFatal entries passed to it.
	LogInfo

	// LogDebug tells a logger to log all LogDebug, LogInfo, LogWarning, LogError, LogPanic and LogFatal entries passed to it.
	LogDebug
	)

	const (
	logNone = "NONE"
	logFatal = "FATAL"
	logPanic = "PANIC"
	logError = "ERROR"
	logWarning = "WARNING"
	logInfo = "INFO"
	logDebug = "DEBUG"
	logUnknown = "UNKNOWN"
	)

	// ParseLevel converts the specified string into the corresponding LevelType.
	func ParseLevel(s string) (lt LevelType, err error) {
	switch strings.ToUpper(s) {
	case logFatal:
	lt = LogFatal
	case logPanic:
	lt = LogPanic
	case logError:
	lt = LogError
	case logWarning:
	lt = LogWarning
	case logInfo:
	lt = LogInfo
	case logDebug:
	lt = LogDebug
	default:
	err = fmt.Errorf("bad log level '%s'", s)
	}
	return
	}

	// String implements the stringer interface for LevelType.
	func (lt LevelType) String() string {
	switch lt {
	case LogNone:
	return logNone
	case LogFatal:
	return logFatal
	case LogPanic:
	return logPanic
	case LogError:
	return logError
	case LogWarning:
	return logWarning
	case LogInfo:
	return logInfo
	case LogDebug:
	return logDebug
	default:
	return logUnknown
	}
	}

	// Filter defines functions for filtering HTTP request/response content.
	type Filter struct {
	// URL returns a potentially modified string representation of a request URL.
	URL func(u *url.URL) string

	// Header returns a potentially modified set of values for the specified key.
	// To completely exclude the header key/values return false.
	Header func(key string, val []string) (bool, []string)

	// Body returns a potentially modified request/response body.
	Body func(b []byte) []byte
	}

	func (f Filter) processURL(u *url.URL) string {
	if f.URL == nil {
	return u.String()
	}
	return f.URL(u)
	}

	func (f Filter) processHeader(k string, val []string) (bool, []string) {
	if f.Header == nil {
	return true, val
	}
	return f.Header(k, val)
	}

	func (f Filter) processBody(b []byte) []byte {
	if f.Body == nil {
	return b
	}
	return f.Body(b)
	}

	// Writer defines methods for writing to a logging facility.
	type Writer interface {
	// Writeln writes the specified message with the standard log entry header and new-line character.
	Writeln(level LevelType, message string)

	// Writef writes the specified format specifier with the standard log entry header and no new-line character.
	Writef(level LevelType, format string, a ...interface{})

	// WriteRequest writes the specified HTTP request to the logger if the log level is greater than
	// or equal to LogInfo. The request body, if set, is logged at level LogDebug or higher.
	// Custom filters can be specified to exclude URL, header, and/or body content from the log.
	// By default no request content is excluded.
	WriteRequest(req *http.Request, filter Filter)

	// WriteResponse writes the specified HTTP response to the logger if the log level is greater than
	// or equal to LogInfo. The response body, if set, is logged at level LogDebug or higher.
	// Custom filters can be specified to exclude URL, header, and/or body content from the log.
	// By default no response content is excluded.
	WriteResponse(resp *http.Response, filter Filter)
	}

	// Instance is the default log writer initialized during package init.
	// This can be replaced with a custom implementation as required.
	var Instance Writer

	// default log level
	var logLevel = LogNone

	// Level returns the value specified in AZURE_GO_AUTOREST_LOG_LEVEL.
	// If no value was specified the default value is LogNone.
	// Custom loggers can call this to retrieve the configured log level.
	func Level() LevelType {
	return logLevel
	}

	func init() {
	// separated for testing purposes
	initDefaultLogger()
	}

	func initDefaultLogger() {
	// init with nilLogger so callers don't have to do a nil check on Default
	Instance = nilLogger{}
	llStr := strings.ToLower(os.Getenv("AZURE_GO_SDK_LOG_LEVEL"))
	if llStr == "" {
	return
	}
	var err error
	logLevel, err = ParseLevel(llStr)
	if err != nil {
	fmt.Fprintf(os.Stderr, "go-autorest: failed to parse log level: %s\n", err.Error())
	return
	}
	if logLevel == LogNone {
	return
	}
	// default to stderr
	dest := os.Stderr
	lfStr := os.Getenv("AZURE_GO_SDK_LOG_FILE")
	if strings.EqualFold(lfStr, "stdout") {
	dest = os.Stdout
	} else if lfStr != "" {
	lf, err := os.Create(lfStr)
	if err == nil {
	dest = lf
	} else {
	fmt.Fprintf(os.Stderr, "go-autorest: failed to create log file, using stderr: %s\n", err.Error())
	}
	}
	Instance = fileLogger{
	logLevel: logLevel,
	mu: &sync.Mutex{},
	logFile: dest,
	}
	}

	// the nil logger does nothing
	type nilLogger struct{}

	func (nilLogger) Writeln(LevelType, string) {}

	func (nilLogger) Writef(LevelType, string, ...interface{}) {}

	func (nilLogger) WriteRequest(*http.Request, Filter) {}

	func (nilLogger) WriteResponse(*http.Response, Filter) {}

	// A File is used instead of a Logger so the stream can be flushed after every write.
	type fileLogger struct {
	logLevel LevelType
	mu *sync.Mutex // for synchronizing writes to logFile
	logFile *os.File
	}

	func (fl fileLogger) Writeln(level LevelType, message string) {
	fl.Writef(level, "%s\n", message)
	}

	func (fl fileLogger) Writef(level LevelType, format string, a ...interface{}) {
	if fl.logLevel >= level {
	fl.mu.Lock()
	defer fl.mu.Unlock()
	fmt.Fprintf(fl.logFile, "%s %s", entryHeader(level), fmt.Sprintf(format, a...))
	fl.logFile.Sync()
	}
	}

	func (fl fileLogger) WriteRequest(req *http.Request, filter Filter) {
	if req == nil \|\| fl.logLevel < LogInfo {
	return
	}
	b := &bytes.Buffer{}
	fmt.Fprintf(b, "%s REQUEST: %s %s\n", entryHeader(LogInfo), req.Method, filter.processURL(req.URL))
	// dump headers
	for k, v := range req.Header {
	if ok, mv := filter.processHeader(k, v); ok {
	fmt.Fprintf(b, "%s: %s\n", k, strings.Join(mv, ","))
	}
	}
	if fl.shouldLogBody(req.Header, req.Body) {
	// dump body
	body, err := ioutil.ReadAll(req.Body)
	if err == nil {
	fmt.Fprintln(b, string(filter.processBody(body)))
	if nc, ok := req.Body.(io.Seeker); ok {
	// rewind to the beginning
	nc.Seek(0, io.SeekStart)
	} else {
	// recreate the body
	req.Body = ioutil.NopCloser(bytes.NewReader(body))
	}
	} else {
	fmt.Fprintf(b, "failed to read body: %v\n", err)
	}
	}
	fl.mu.Lock()
	defer fl.mu.Unlock()
	fmt.Fprint(fl.logFile, b.String())
	fl.logFile.Sync()
	}

	func (fl fileLogger) WriteResponse(resp *http.Response, filter Filter) {
	if resp == nil \|\| fl.logLevel < LogInfo {
	return
	}
	b := &bytes.Buffer{}
	fmt.Fprintf(b, "%s RESPONSE: %d %s\n", entryHeader(LogInfo), resp.StatusCode, filter.processURL(resp.Request.URL))
	// dump headers
	for k, v := range resp.Header {
	if ok, mv := filter.processHeader(k, v); ok {
	fmt.Fprintf(b, "%s: %s\n", k, strings.Join(mv, ","))
	}
	}
	if fl.shouldLogBody(resp.Header, resp.Body) {
	// dump body
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err == nil {
	fmt.Fprintln(b, string(filter.processBody(body)))
	resp.Body = ioutil.NopCloser(bytes.NewReader(body))
	} else {
	fmt.Fprintf(b, "failed to read body: %v\n", err)
	}
	}
	fl.mu.Lock()
	defer fl.mu.Unlock()
	fmt.Fprint(fl.logFile, b.String())
	fl.logFile.Sync()
	}

	// returns true if the provided body should be included in the log
	func (fl fileLogger) shouldLogBody(header http.Header, body io.ReadCloser) bool {
	ct := header.Get("Content-Type")
	return fl.logLevel >= LogDebug && body != nil && !strings.Contains(ct, "application/octet-stream")
	}

	// creates standard header for log entries, it contains a timestamp and the log level
	func entryHeader(level LevelType) string {
	// this format provides a fixed number of digits so the size of the timestamp is constant
	return fmt.Sprintf("(%s) %s:", time.Now().Format("2006-01-02T15:04:05.0000000Z07:00"), level.String())
	}