diff --git a/state/state.go b/state/state.go
index 1825900..9ae9d5f 100644
--- a/state/state.go
+++ b/state/state.go
@@ -3,7 +3,6 @@
 package state
 
 import (
-	"log"
 	"sync"
 
 	"github.com/diamondburned/arikawa/discord"
@@ -27,10 +26,10 @@ type State struct {
 	// Ready is not updated by the state.
 	Ready gateway.ReadyEvent
 
-	// ErrorLog logs all errors that handler might have, including state fails.
-	// This handler will also be used for Session, which would also be used for
-	// Gateway. Defaults to log.Println.
-	ErrorLog func(error)
+	// StateLog logs all errors that come from the state cache. This includes
+	// not found errors. Defaults to a no-op, as state errors aren't that
+	// important.
+	StateLog func(error)
 
 	// PreHandler is the manual hook that is executed before the State handler
 	// is. This should only be used for low-level operations.
@@ -47,11 +46,9 @@ type State struct {
 
 func NewFromSession(s *session.Session, store Store) (*State, error) {
 	state := &State{
-		Session: s,
-		Store:   store,
-		ErrorLog: func(err error) {
-			log.Println("arikawa/state error:", err)
-		},
+		Session:  s,
+		Store:    store,
+		StateLog: func(err error) {},
 	}
 
 	s.ErrorLog = func(err error) {
diff --git a/state/state_events.go b/state/state_events.go
index 000cd86..34a893f 100644
--- a/state/state_events.go
+++ b/state/state_events.go
@@ -25,20 +25,20 @@ func (s *State) onEvent(iface interface{}) {
 		// Handle guilds
 		for _, g := range ev.Guilds {
 			if err := s.Store.GuildSet(&g); err != nil {
-				s.wrapErr(err, "Failed to set guild in state")
+				s.stateErr(err, "Failed to set guild in state")
 			}
 		}
 
 		// Handle private channels
 		for _, ch := range ev.PrivateChannels {
 			if err := s.Store.ChannelSet(&ch); err != nil {
-				s.wrapErr(err, "Failed to set channel in state")
+				s.stateErr(err, "Failed to set channel in state")
 			}
 		}
 
 		// Handle user
 		if err := s.Store.SelfSet(&ev.User); err != nil {
-			s.wrapErr(err, "Failed to set self in state")
+			s.stateErr(err, "Failed to set self in state")
 		}
 
 		// Set Ready to the state
@@ -46,12 +46,12 @@ func (s *State) onEvent(iface interface{}) {
 
 	case *gateway.GuildCreateEvent:
 		if err := s.Store.GuildSet(&ev.Guild); err != nil {
-			s.wrapErr(err, "Failed to create guild in state")
+			s.stateErr(err, "Failed to create guild in state")
 		}
 
 		for _, m := range ev.Members {
 			if err := s.Store.MemberSet(ev.Guild.ID, &m); err != nil {
-				s.wrapErr(err, "Failed to add a member from guild in state")
+				s.stateErr(err, "Failed to add a member from guild in state")
 			}
 		}
 
@@ -59,27 +59,27 @@ func (s *State) onEvent(iface interface{}) {
 			ch.GuildID = ev.Guild.ID // just to make sure
 
 			if err := s.Store.ChannelSet(&ch); err != nil {
-				s.wrapErr(err, "Failed to add a channel from guild in state")
+				s.stateErr(err, "Failed to add a channel from guild in state")
 			}
 		}
 
 		for _, p := range ev.Presences {
 			if err := s.Store.PresenceSet(ev.Guild.ID, &p); err != nil {
-				s.wrapErr(err, "Failed to add a presence from guild in state")
+				s.stateErr(err, "Failed to add a presence from guild in state")
 			}
 		}
 	case *gateway.GuildUpdateEvent:
 		if err := s.Store.GuildSet((*discord.Guild)(ev)); err != nil {
-			s.wrapErr(err, "Failed to update guild in state")
+			s.stateErr(err, "Failed to update guild in state")
 		}
 	case *gateway.GuildDeleteEvent:
 		if err := s.Store.GuildRemove(ev.ID); err != nil {
-			s.wrapErr(err, "Failed to delete guild in state")
+			s.stateErr(err, "Failed to delete guild in state")
 		}
 
 	case *gateway.GuildMemberAddEvent:
 		if err := s.Store.MemberSet(ev.GuildID, &ev.Member); err != nil {
-			s.wrapErr(err, "Failed to add a member in state")
+			s.stateErr(err, "Failed to add a member in state")
 		}
 	case *gateway.GuildMemberUpdateEvent:
 		m, err := s.Store.Member(ev.GuildID, ev.User.ID)
@@ -92,75 +92,75 @@ func (s *State) onEvent(iface interface{}) {
 		ev.Update(m)
 
 		if err := s.Store.MemberSet(ev.GuildID, m); err != nil {
-			s.wrapErr(err, "Failed to update a member in state")
+			s.stateErr(err, "Failed to update a member in state")
 		}
 	case *gateway.GuildMemberRemoveEvent:
 		if err := s.Store.MemberRemove(ev.GuildID, ev.User.ID); err != nil {
-			s.wrapErr(err, "Failed to remove a member in state")
+			s.stateErr(err, "Failed to remove a member in state")
 		}
 
 	case *gateway.GuildMembersChunkEvent:
 		for _, m := range ev.Members {
 			if err := s.Store.MemberSet(ev.GuildID, &m); err != nil {
-				s.wrapErr(err, "Failed to add a member from chunk in state")
+				s.stateErr(err, "Failed to add a member from chunk in state")
 			}
 		}
 
 		for _, p := range ev.Presences {
 			if err := s.Store.PresenceSet(ev.GuildID, &p); err != nil {
-				s.wrapErr(err, "Failed to add a presence from chunk in state")
+				s.stateErr(err, "Failed to add a presence from chunk in state")
 			}
 		}
 
 	case *gateway.GuildRoleCreateEvent:
 		if err := s.Store.RoleSet(ev.GuildID, &ev.Role); err != nil {
-			s.wrapErr(err, "Failed to add a role in state")
+			s.stateErr(err, "Failed to add a role in state")
 		}
 	case *gateway.GuildRoleUpdateEvent:
 		if err := s.Store.RoleSet(ev.GuildID, &ev.Role); err != nil {
-			s.wrapErr(err, "Failed to update a role in state")
+			s.stateErr(err, "Failed to update a role in state")
 		}
 	case *gateway.GuildRoleDeleteEvent:
 		if err := s.Store.RoleRemove(ev.GuildID, ev.RoleID); err != nil {
-			s.wrapErr(err, "Failed to remove a role in state")
+			s.stateErr(err, "Failed to remove a role in state")
 		}
 
 	case *gateway.GuildEmojisUpdateEvent:
 		if err := s.Store.EmojiSet(ev.GuildID, ev.Emojis); err != nil {
-			s.wrapErr(err, "Failed to update emojis in state")
+			s.stateErr(err, "Failed to update emojis in state")
 		}
 
 	case *gateway.ChannelCreateEvent:
 		if err := s.Store.ChannelSet((*discord.Channel)(ev)); err != nil {
-			s.wrapErr(err, "Failed to create a channel in state")
+			s.stateErr(err, "Failed to create a channel in state")
 		}
 	case *gateway.ChannelUpdateEvent:
 		if err := s.Store.ChannelSet((*discord.Channel)(ev)); err != nil {
-			s.wrapErr(err, "Failed to update a channel in state")
+			s.stateErr(err, "Failed to update a channel in state")
 		}
 	case *gateway.ChannelDeleteEvent:
 		if err := s.Store.ChannelRemove((*discord.Channel)(ev)); err != nil {
-			s.wrapErr(err, "Failed to remove a channel in state")
+			s.stateErr(err, "Failed to remove a channel in state")
 		}
 
 		// *gateway.ChannelPinsUpdateEvent is not tracked.
 
 	case *gateway.MessageCreateEvent:
 		if err := s.Store.MessageSet((*discord.Message)(ev)); err != nil {
-			s.wrapErr(err, "Failed to add a message in state")
+			s.stateErr(err, "Failed to add a message in state")
 		}
 	case *gateway.MessageUpdateEvent:
 		if err := s.Store.MessageSet((*discord.Message)(ev)); err != nil {
-			s.wrapErr(err, "Failed to update a message in state")
+			s.stateErr(err, "Failed to update a message in state")
 		}
 	case *gateway.MessageDeleteEvent:
 		if err := s.Store.MessageRemove(ev.ChannelID, ev.ID); err != nil {
-			s.wrapErr(err, "Failed to delete a message in state")
+			s.stateErr(err, "Failed to delete a message in state")
 		}
 	case *gateway.MessageDeleteBulkEvent:
 		for _, id := range ev.IDs {
 			if err := s.Store.MessageRemove(ev.ChannelID, id); err != nil {
-				s.wrapErr(err, "Failed to delete bulk meessages in state")
+				s.stateErr(err, "Failed to delete bulk meessages in state")
 			}
 		}
 
@@ -168,11 +168,11 @@ func (s *State) onEvent(iface interface{}) {
 		if err := s.Store.PresenceSet(
 			ev.GuildID, (*discord.Presence)(ev)); err != nil {
 
-			s.wrapErr(err, "Failed to update presence in state")
+			s.stateErr(err, "Failed to update presence in state")
 		}
 	}
 }
 
-func (s *State) wrapErr(err error, wrap string) {
+func (s *State) stateErr(err error, wrap string) {
 	s.ErrorLog(errors.Wrap(err, wrap))
 }