diff --git a/examples/basic/basic.go b/examples/basic/basic.go
index 87f5f61..dc5b22f 100644
--- a/examples/basic/basic.go
+++ b/examples/basic/basic.go
@@ -18,5 +18,11 @@ func main() {
 	gologger.Debug().Str("state", "running").Msg("planner running")
 	gologger.Debug().TimeStamp().Str("state", "running").Msg("with timestamp event")
 	gologger.Warning().Str("state", "errored").Str("status", "404").Msg("could not run")
+
+	// with timestamp
+	gologger.DefaultLogger.SetTimestamp(true, levels.LevelDebug)
+	gologger.Debug().Msg("with automatic timestamp")
+	gologger.Info().Msg("without automatic timestamp")
+
 	gologger.Fatal().Msg("bye bye")
 }
diff --git a/gologger.go b/gologger.go
index dc2b762..5aab171 100644
--- a/gologger.go
+++ b/gologger.go
@@ -33,9 +33,11 @@ func init() {
 
 // Logger is a logger for logging structured data in a beautfiul and fast manner.
 type Logger struct {
-	writer    writer.Writer
-	maxLevel  levels.Level
-	formatter formatter.Formatter
+	writer            writer.Writer
+	maxLevel          levels.Level
+	formatter         formatter.Formatter
+	timestampMinLevel levels.Level
+	timestamp         bool
 }
 
 // Log logs a message to a logger instance
@@ -74,6 +76,12 @@ func (l *Logger) SetWriter(writer writer.Writer) {
 	l.writer = writer
 }
 
+// SetTimestamp enables/disables automatic timestamp
+func (l *Logger) SetTimestamp(timestamp bool, minLevel levels.Level) {
+	l.timestamp = timestamp
+	l.timestampMinLevel = minLevel
+}
+
 // Event is a log event to be written with data
 type Event struct {
 	logger   *Logger
@@ -82,6 +90,26 @@ type Event struct {
 	metadata map[string]string
 }
 
+func newDefaultEventWithLevel(level levels.Level) *Event {
+	return newEventWithLevelAndLogger(level, DefaultLogger)
+}
+
+func newEventWithLevelAndLogger(level levels.Level, l *Logger) *Event {
+	event := &Event{
+		logger:   l,
+		level:    level,
+		metadata: make(map[string]string),
+	}
+	if l.timestamp && level >= l.timestampMinLevel {
+		event.TimeStamp()
+	}
+	return event
+}
+
+func (e *Event) setLevelMetadata(level levels.Level) {
+	e.metadata["label"] = labels[level]
+}
+
 // Label applies a custom label on the log event
 func (e *Event) Label(label string) *Event {
 	e.metadata["label"] = label
@@ -124,178 +152,104 @@ func (e *Event) MsgFunc(messageSupplier func() string) {
 
 // Info writes a info message on the screen with the default label
 func Info() *Event {
-	level := levels.LevelInfo
-	event := &Event{
-		logger:   DefaultLogger,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newDefaultEventWithLevel(levels.LevelInfo)
+	event.setLevelMetadata(levels.LevelInfo)
 	return event
 }
 
 // Warning writes a warning message on the screen with the default label
 func Warning() *Event {
-	level := levels.LevelWarning
-	event := &Event{
-		logger:   DefaultLogger,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newDefaultEventWithLevel(levels.LevelWarning)
+	event.setLevelMetadata(levels.LevelWarning)
 	return event
 }
 
 // Error writes a error message on the screen with the default label
 func Error() *Event {
-	level := levels.LevelError
-	event := &Event{
-		logger:   DefaultLogger,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newDefaultEventWithLevel(levels.LevelError)
+	event.setLevelMetadata(levels.LevelError)
 	return event
 }
 
 // Debug writes an error message on the screen with the default label
 func Debug() *Event {
-	level := levels.LevelDebug
-	event := &Event{
-		logger:   DefaultLogger,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newDefaultEventWithLevel(levels.LevelDebug)
+	event.setLevelMetadata(levels.LevelDebug)
 	return event
 }
 
 // Fatal exits the program if we encounter a fatal error
 func Fatal() *Event {
-	level := levels.LevelFatal
-	event := &Event{
-		logger:   DefaultLogger,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newDefaultEventWithLevel(levels.LevelFatal)
+	event.setLevelMetadata(levels.LevelFatal)
 	return event
 }
 
 // Silent prints a string on stdout without any extra labels.
 func Silent() *Event {
-	level := levels.LevelSilent
-	event := &Event{
-		logger:   DefaultLogger,
-		level:    level,
-		metadata: make(map[string]string),
-	}
+	event := newDefaultEventWithLevel(levels.LevelSilent)
+	event.setLevelMetadata(levels.LevelSilent)
 	return event
 }
 
 // Print prints a string on stderr without any extra labels.
 func Print() *Event {
-	level := levels.LevelInfo
-	event := &Event{
-		logger:   DefaultLogger,
-		level:    level,
-		metadata: make(map[string]string),
-	}
+	event := newDefaultEventWithLevel(levels.LevelInfo)
 	return event
 }
 
 // Verbose prints a string only in verbose output mode.
 func Verbose() *Event {
-	level := levels.LevelVerbose
-	event := &Event{
-		logger:   DefaultLogger,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newDefaultEventWithLevel(levels.LevelVerbose)
+	event.setLevelMetadata(levels.LevelVerbose)
 	return event
 }
 
 // Info writes a info message on the screen with the default label
 func (l *Logger) Info() *Event {
-	level := levels.LevelInfo
-	event := &Event{
-		logger:   l,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newEventWithLevelAndLogger(levels.LevelInfo, l)
+	event.setLevelMetadata(levels.LevelInfo)
 	return event
 }
 
 // Warning writes a warning message on the screen with the default label
 func (l *Logger) Warning() *Event {
-	level := levels.LevelWarning
-	event := &Event{
-		logger:   l,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newEventWithLevelAndLogger(levels.LevelWarning, l)
+	event.setLevelMetadata(levels.LevelWarning)
 	return event
 }
 
 // Error writes a error message on the screen with the default label
 func (l *Logger) Error() *Event {
-	level := levels.LevelError
-	event := &Event{
-		logger:   l,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newEventWithLevelAndLogger(levels.LevelError, l)
+	event.setLevelMetadata(levels.LevelError)
 	return event
 }
 
 // Debug writes an error message on the screen with the default label
 func (l *Logger) Debug() *Event {
-	level := levels.LevelDebug
-	event := &Event{
-		logger:   l,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newEventWithLevelAndLogger(levels.LevelDebug, l)
+	event.setLevelMetadata(levels.LevelDebug)
 	return event
 }
 
 // Fatal exits the program if we encounter a fatal error
 func (l *Logger) Fatal() *Event {
-	level := levels.LevelFatal
-	event := &Event{
-		logger:   l,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newEventWithLevelAndLogger(levels.LevelFatal, l)
+	event.setLevelMetadata(levels.LevelFatal)
 	return event
 }
 
 // Print prints a string on screen without any extra labels.
 func (l *Logger) Print() *Event {
-	level := levels.LevelSilent
-	event := &Event{
-		logger:   l,
-		level:    level,
-		metadata: make(map[string]string),
-	}
+	event := newEventWithLevelAndLogger(levels.LevelSilent, l)
 	return event
 }
 
 // Verbose prints a string only in verbose output mode.
 func (l *Logger) Verbose() *Event {
-	level := levels.LevelVerbose
-	event := &Event{
-		logger:   l,
-		level:    level,
-		metadata: make(map[string]string),
-	}
-	event.metadata["label"] = labels[level]
+	event := newEventWithLevelAndLogger(levels.LevelVerbose, l)
+	event.setLevelMetadata(levels.LevelVerbose)
 	return event
 }