diff --git a/jww_test.go b/jww_test.go
index b6d118a..c405185 100644
--- a/jww_test.go
+++ b/jww_test.go
@@ -1,4 +1,4 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
+// Copyright © 2016 Steve Francia <spf@spf13.com>.
 //
 // Use of this source code is governed by an MIT-style
 // license that can be found in the LICENSE file.
@@ -6,51 +6,91 @@
 package jwalterweatherman
 
 import (
-    "bytes"
-    "github.com/stretchr/testify/assert"
-    "testing"
+	"bytes"
+	"github.com/stretchr/testify/assert"
+	"sync"
+	"testing"
 )
 
 func TestLevels(t *testing.T) {
-    SetStdoutThreshold(LevelError)
-    assert.Equal(t, StdoutThreshold(), LevelError)
-    SetLogThreshold(LevelCritical)
-    assert.Equal(t, LogThreshold(), LevelCritical)
-    assert.NotEqual(t, StdoutThreshold(), LevelCritical)
-    SetStdoutThreshold(LevelWarn)
-    assert.Equal(t, StdoutThreshold(), LevelWarn)
+	SetStdoutThreshold(LevelError)
+	assert.Equal(t, StdoutThreshold(), LevelError)
+	SetLogThreshold(LevelCritical)
+	assert.Equal(t, LogThreshold(), LevelCritical)
+	assert.NotEqual(t, StdoutThreshold(), LevelCritical)
+	SetStdoutThreshold(LevelWarn)
+	assert.Equal(t, StdoutThreshold(), LevelWarn)
 }
 
 func TestDefaultLogging(t *testing.T) {
-    outputBuf := new(bytes.Buffer)
-    logBuf := new(bytes.Buffer)
-    LogHandle = logBuf
-    OutHandle = outputBuf
+	outputBuf := new(bytes.Buffer)
+	logBuf := new(bytes.Buffer)
+	LogHandle = logBuf
+	OutHandle = outputBuf
 
-    SetLogThreshold(LevelWarn)
-    SetStdoutThreshold(LevelError)
+	SetLogThreshold(LevelWarn)
+	SetStdoutThreshold(LevelError)
 
-    FATAL.Println("fatal err")
-    CRITICAL.Println("critical err")
-    ERROR.Println("an error")
-    WARN.Println("a warning")
-    INFO.Println("information")
-    DEBUG.Println("debugging info")
-    TRACE.Println("trace")
+	FATAL.Println("fatal err")
+	CRITICAL.Println("critical err")
+	ERROR.Println("an error")
+	WARN.Println("a warning")
+	INFO.Println("information")
+	DEBUG.Println("debugging info")
+	TRACE.Println("trace")
 
-    assert.Contains(t, logBuf.String(), "fatal err")
-    assert.Contains(t, logBuf.String(), "critical err")
-    assert.Contains(t, logBuf.String(), "an error")
-    assert.Contains(t, logBuf.String(), "a warning")
-    assert.NotContains(t, logBuf.String(), "information")
-    assert.NotContains(t, logBuf.String(), "debugging info")
-    assert.NotContains(t, logBuf.String(), "trace")
+	assert.Contains(t, logBuf.String(), "fatal err")
+	assert.Contains(t, logBuf.String(), "critical err")
+	assert.Contains(t, logBuf.String(), "an error")
+	assert.Contains(t, logBuf.String(), "a warning")
+	assert.NotContains(t, logBuf.String(), "information")
+	assert.NotContains(t, logBuf.String(), "debugging info")
+	assert.NotContains(t, logBuf.String(), "trace")
 
-    assert.Contains(t, outputBuf.String(), "fatal err")
-    assert.Contains(t, outputBuf.String(), "critical err")
-    assert.Contains(t, outputBuf.String(), "an error")
-    assert.NotContains(t, outputBuf.String(), "a warning")
-    assert.NotContains(t, outputBuf.String(), "information")
-    assert.NotContains(t, outputBuf.String(), "debugging info")
-    assert.NotContains(t, outputBuf.String(), "trace")
+	assert.Contains(t, outputBuf.String(), "fatal err")
+	assert.Contains(t, outputBuf.String(), "critical err")
+	assert.Contains(t, outputBuf.String(), "an error")
+	assert.NotContains(t, outputBuf.String(), "a warning")
+	assert.NotContains(t, outputBuf.String(), "information")
+	assert.NotContains(t, outputBuf.String(), "debugging info")
+	assert.NotContains(t, outputBuf.String(), "trace")
+}
+
+func TestLogCounter(t *testing.T) {
+	ResetLogCounters()
+
+	FATAL.Println("fatal err")
+	CRITICAL.Println("critical err")
+	WARN.Println("a warning")
+	WARN.Println("another warning")
+	INFO.Println("information")
+	DEBUG.Println("debugging info")
+	TRACE.Println("trace")
+
+	wg := &sync.WaitGroup{}
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 10; j++ {
+				ERROR.Println("error", j)
+				// check for data races
+				assert.True(t, LogCountForLevel(LevelError) > uint64(j))
+				assert.True(t, LogCountForLevelsGreaterThanorEqualTo(LevelError) > uint64(j))
+			}
+		}()
+
+	}
+
+	wg.Wait()
+
+	assert.Equal(t, uint64(1), LogCountForLevel(LevelFatal))
+	assert.Equal(t, uint64(1), LogCountForLevel(LevelCritical))
+	assert.Equal(t, uint64(2), LogCountForLevel(LevelWarn))
+	assert.Equal(t, uint64(1), LogCountForLevel(LevelInfo))
+	assert.Equal(t, uint64(1), LogCountForLevel(LevelDebug))
+	assert.Equal(t, uint64(1), LogCountForLevel(LevelTrace))
+	assert.Equal(t, uint64(100), LogCountForLevel(LevelError))
+	assert.Equal(t, uint64(102), LogCountForLevelsGreaterThanorEqualTo(LevelError))
 }
diff --git a/thatswhyyoualwaysleaveanote.go b/thatswhyyoualwaysleaveanote.go
index 30f6d54..df5970c 100644
--- a/thatswhyyoualwaysleaveanote.go
+++ b/thatswhyyoualwaysleaveanote.go
@@ -1,4 +1,4 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
+// Copyright © 2016 Steve Francia <spf@spf13.com>.
 //
 // Use of this source code is governed by an MIT-style
 // license that can be found in the LICENSE file.
@@ -11,6 +11,7 @@
 	"io/ioutil"
 	"log"
 	"os"
+	"sync/atomic"
 )
 
 // Level describes the chosen log level between
@@ -18,10 +19,33 @@
 type Level int
 
 type NotePad struct {
-	Handle io.Writer
-	Level  Level
-	Prefix string
-	Logger **log.Logger
+	Handle  io.Writer
+	Level   Level
+	Prefix  string
+	Logger  **log.Logger
+	counter uint64
+}
+
+func (n *NotePad) incr() {
+	atomic.AddUint64(&n.counter, 1)
+}
+
+func (n *NotePad) resetCounter() {
+	atomic.StoreUint64(&n.counter, 0)
+}
+
+func (n *NotePad) getCount() uint64 {
+	return atomic.LoadUint64(&n.counter)
+}
+
+type countingWriter struct {
+	incrFunc func()
+}
+
+func (cw *countingWriter) Write(p []byte) (n int, err error) {
+	cw.incrFunc()
+
+	return 0, nil
 }
 
 // Feedback is special. It writes plainly to the output while
@@ -101,6 +125,7 @@
 	}
 
 	for _, n := range NotePads {
+		n.Handle = io.MultiWriter(n.Handle, &countingWriter{n.incr})
 		*n.Logger = log.New(n.Handle, n.Prefix, logFlags)
 	}
 
@@ -176,6 +201,35 @@
 	initialize()
 }
 
+// LogCountForLevel returns the number of log invocations for a given level.
+func LogCountForLevel(l Level) uint64 {
+	for _, np := range NotePads {
+		if np.Level == l {
+			return np.getCount()
+		}
+	}
+	return 0
+}
+
+// LogCountForLevelsGreaterThanorEqualTo returns the number of log invocations
+// greater than or equal to a given level threshold.
+func LogCountForLevelsGreaterThanorEqualTo(threshold Level) uint64 {
+	var cnt uint64
+	for _, np := range NotePads {
+		if np.Level >= threshold {
+			cnt += np.getCount()
+		}
+	}
+	return cnt
+}
+
+// ResetLogCounters resets the invocation counters for all levels.
+func ResetLogCounters() {
+	for _, np := range NotePads {
+		np.resetCounter()
+	}
+}
+
 // Disables logging for the entire JWW system
 func DiscardLogging() {
 	LogHandle = ioutil.Discard