func OutputLevel(level Level, calldepth int, s string) error {
	return std.OutputLevel(level, calldepth+1, s) // +1 for this frame.
}

func Output(calldepth int, s string) error {
	return std.OutputLevel(NoneLevel, calldepth+1, s) // +1 for this frame.
}

// SetLoggerLevel sets the log level for the logger.
func (l *Logger) SetLoggerLevel(level Level) {}

log.SetFlags(LstdFlags | Llevel | Lmsgprefix)

type Level uint32

// These are the different logger levels. You can set the logger level
// on your instance of logger
const (
	NoneLevel Level = -(iota + 1)
	PanicLevel
	FatalLevel
	ErrorLevel
	WarnLevel
	InfoLevel
	DebugLevel
	TraceLevel
)

func (l *Logger) Error(v ...interface{}) {}

// Errorf is equivalent to Printf() and logs the message at level Error.
func (l *Logger) Errorf(format string, v ...interface{}) {}

// Errorln is equivalent to Println() and logs the message at level Error.
func (l *Logger) Errorln(v ...interface{}) {}

// Warn is equivalent to Print() and logs the message at level Warning.
func (l *Logger) Warn(v ...interface{}) {}

// Warnf is equivalent to Printf() and logs the message at level Warning.
func (l *Logger) Warnf(format string, v ...interface{})}

// Warnln is equivalent to Println() and logs the message at level Warning.
func (l *Logger) Warnln(v ...interface{}) {}

// Info is equivalent to Print() and logs the message at level Info.
func (l *Logger) Info(v ...interface{}) {}

// Infof is equivalent to Printf() and logs the message at level Info.
func (l *Logger) Infof(format string, v ...interface{}) {}

// Infoln is equivalent to Println() and logs the message at level Info.
func (l *Logger) Infoln(v ...interface{}) {}

// Debug is equivalent to Print() and logs the message at level Debug.
func (l *Logger) Debug(v ...interface{}) {}

// Debugf is equivalent to Printf() and logs the message at level Debug.
func (l *Logger) Debugf(format string, v ...interface{}) {}

// Debugln is equivalent to Println() and logs the message at level Debug.
func (l *Logger) Debugln(v ...interface{}) {}

// Trace is equivalent to Print() and logs the message at level Trace.
func (l *Logger) Trace(v ...interface{}) {}

// Tracef is equivalent to Printf() and logs the message at level Trace.
func (l *Logger) Tracef(format string, v ...interface{}) {}

// Traceln is equivalent to Println() and logs the message at level Trace.
func (l *Logger) Traceln(v ...interface{}) {}

// The LoggerFormatter interface is used to implement a custom formatter.
// So the log output can be customized by implementing this interface.
type LoggerFormatter interface {
	Format(entry *Entry) ([]byte, error)
}

// The Entry is a logging entry that contains context set by the user and needed data
// for the log.
// Entry fields are used by a custom formatter while formatting output.
type Entry struct {
	logger    *Logger         // logger which will be used to log the entry
	context   context.Context // context set by the user
	calldepth int             // calldepth is the count of the number of frames to skip
	level     *Level          // level of the entry
	message   string          // message contains the text to print
}

// Logger returns the logger which will write entry to the output destination.
func (e *Entry) Logger() *Logger {}

// Context returns the context set by the user for entry.
func (e *Entry) Context() context.Context {}

// LogLevel returns the log level for entry.
func (e *Entry) LogLevel() *Level {}

// Message returns the log message for entry.
func (e *Entry) Message() string {}

// CallDepth returns the calldepth for entry.
func (e *Entry) CallDepth() int {}

// Print, Panic, Fatal, Error, Info methods...

func (l *Logger) Formatter() LoggerFormatter {}

// SetFormatter sets the formatter for the logger.
func (l *Logger) SetFormatter(formatter LoggerFormatter) {}

type testFormatter struct {
}

func (f *testFormatter) Format(entry *log.Entry) ([]byte, error) {
	prefix := entry.Logger().Prefix()
	level := log.LevelText(*entry.LogLevel())
	traceId := entry.Context().Value("traceId")
	
	return []byte(prefix + " " + level + " [" + traceId.(string) + "] " + entry.Message()), nil
}

// WithContext creates an entry from the logger and adds a context to it.
func (l *Logger) WithContext(ctx context.Context) *Entry {
	entry := l.newEntry()
	entry.context = ctx
	return entry
}

// SetContext sets the context for the logger.
func (l *Logger) SetContext(ctx context.Context) {}

func main() {
	log.SetFlags(LstdFlags | Llevel | Lmsgprefix)
	logger1 := log.GetLogger("logger1 - ")
	logger1.SetLoggerLevel(log.InfoLevel)
	logger1.Info("hello")
	logger1.Warn("hello")
	logger1.Error("hello")
	logger1.WithContext(context.Background()).Trace("hello")
	logger1.Debug("hello")

	logger2 := log.GetLogger("logger2 - ")
	logger2.SetLoggerLevel(log.TraceLevel)
	logger2.Info("hello")
	logger2.Warn("hello")
	logger2.Error("hello")
	logger2.Trace("hello")
	logger2.Debug("hello")
}