diff --git a/level.go b/level.go
index 8f86c430f..3ca888628 100644
--- a/level.go
+++ b/level.go
@@ -57,6 +57,9 @@ type LevelEnablerFunc func(zapcore.Level) bool
 // Enabled calls the wrapped function.
 func (f LevelEnablerFunc) Enabled(lvl zapcore.Level) bool { return f(lvl) }
 
+// Level returns default level
+func (f LevelEnablerFunc) Level() zapcore.Level { return zapcore.DebugLevel }
+
 // An AtomicLevel is an atomically changeable, dynamic logging level. It lets
 // you safely change the log level of a tree of loggers (the root logger and
 // any children created by adding context) at runtime.
diff --git a/zapcore/core.go b/zapcore/core.go
index a1ef8b034..567387fd0 100644
--- a/zapcore/core.go
+++ b/zapcore/core.go
@@ -49,6 +49,7 @@ type nopCore struct{}
 // NewNopCore returns a no-op Core.
 func NewNopCore() Core                                        { return nopCore{} }
 func (nopCore) Enabled(Level) bool                            { return false }
+func (nopCore) Level() Level                                  { return DebugLevel }
 func (n nopCore) With([]Field) Core                           { return n }
 func (nopCore) Check(_ Entry, ce *CheckedEntry) *CheckedEntry { return ce }
 func (nopCore) Write(Entry, []Field) error                    { return nil }
diff --git a/zapcore/increase_level.go b/zapcore/increase_level.go
index 5a1749261..d09636e89 100644
--- a/zapcore/increase_level.go
+++ b/zapcore/increase_level.go
@@ -45,6 +45,10 @@ func (c *levelFilterCore) Enabled(lvl Level) bool {
 	return c.level.Enabled(lvl)
 }
 
+func (c *levelFilterCore) Level() Level {
+	return c.core.Level()
+}
+
 func (c *levelFilterCore) With(fields []Field) Core {
 	return &levelFilterCore{c.core.With(fields), c.level}
 }
diff --git a/zapcore/level.go b/zapcore/level.go
index 56e88dc0c..4bf3cdc6a 100644
--- a/zapcore/level.go
+++ b/zapcore/level.go
@@ -172,6 +172,11 @@ func (l Level) Enabled(lvl Level) bool {
 	return lvl >= l
 }
 
+// Level returns true if the given level is at or above this level.
+func (l Level) Level() Level {
+	return l
+}
+
 // LevelEnabler decides whether a given logging level is enabled when logging a
 // message.
 //
@@ -184,4 +189,5 @@ func (l Level) Enabled(lvl Level) bool {
 // FatalLevel, but return false for InfoLevel and DebugLevel.
 type LevelEnabler interface {
 	Enabled(Level) bool
+	Level() Level
 }
diff --git a/zapcore/sampler_test.go b/zapcore/sampler_test.go
index f19a6fc9e..dbe94b7cd 100644
--- a/zapcore/sampler_test.go
+++ b/zapcore/sampler_test.go
@@ -151,6 +151,7 @@ func (c *countingCore) Write(Entry, []Field) error {
 
 func (c *countingCore) With([]Field) Core { return c }
 func (*countingCore) Enabled(Level) bool  { return true }
+func (*countingCore) Level() Level        { return DebugLevel }
 func (*countingCore) Sync() error         { return nil }
 
 func TestSamplerConcurrent(t *testing.T) {
diff --git a/zapcore/tee.go b/zapcore/tee.go
index 07a32eef9..34ba07c6e 100644
--- a/zapcore/tee.go
+++ b/zapcore/tee.go
@@ -57,6 +57,13 @@ func (mc multiCore) Enabled(lvl Level) bool {
 	return false
 }
 
+func (mc multiCore) Level() Level {
+	if len(mc) != 0 {
+		return mc[0].Level()
+	}
+	return DebugLevel
+}
+
 func (mc multiCore) Check(ent Entry, ce *CheckedEntry) *CheckedEntry {
 	for i := range mc {
 		ce = mc[i].Check(ent, ce)
diff --git a/zapio/writer_test.go b/zapio/writer_test.go
index 9bdf3488d..bc4abd2a3 100644
--- a/zapio/writer_test.go
+++ b/zapio/writer_test.go
@@ -238,6 +238,7 @@ func BenchmarkWriter(b *testing.B) {
 type partiallyNopCore struct{}
 
 func (*partiallyNopCore) Enabled(zapcore.Level) bool { return true }
+func (*partiallyNopCore) Level() zapcore.Level       { return zapcore.DebugLevel }
 
 func (c *partiallyNopCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
 	return ce.AddCore(ent, c)