make all error messages lowercase

_example/advanced_bot/bot.go

@@ -45,14 +45,14 @@ func (bot *Bot) Say(m *gateway.MessageCreateEvent, f bot.RawArguments) (string,
 	if f != "" {
 		return string(f), nil
 	}
-	return "", errors.New("Missing content.")
+	return "", errors.New("missing content")
 }
 
 // GuildInfo demonstrates the GuildOnly middleware done in (*Bot).Setup().
 func (bot *Bot) GuildInfo(m *gateway.MessageCreateEvent) (string, error) {
 	g, err := bot.Ctx.GuildWithCount(m.GuildID)
 	if err != nil {
-		return "", fmt.Errorf("Failed to get guild: %v", err)
+		return "", fmt.Errorf("failed to get guild: %v", err)
 	}
 
 	return fmt.Sprintf(
@@ -86,7 +86,7 @@ func (bot *Bot) Repeat(m *gateway.MessageCreateEvent) (string, error) {
 	})
 
 	if v == nil {
-		return "", errors.New("Timed out waiting for response.")
+		return "", errors.New("timed out waiting for response")
 	}
 
 	ev := v.(*gateway.MessageCreateEvent)
@@ -110,12 +110,12 @@ func (bot *Bot) Embed(m *gateway.MessageCreateEvent, f arguments.Flag) (*discord
 	}
 
 	if len(fs.Args()) < 1 {
-		return nil, fmt.Errorf("Usage: embed [flags] content...\n" + fs.Usage())
+		return nil, fmt.Errorf("usage: embed [flags] content...\n" + fs.Usage())
 	}
 
 	// Check if the color string is valid.
 	if !strings.HasPrefix(*color, "#") || len(*color) != 7 {
-		return nil, errors.New("Invalid color, format must be #hhhhhh")
+		return nil, errors.New("invalid color, format must be #hhhhhh")
 	}
 
 	// Parse the color into decimal numbers.

api/image.go

@@ -10,9 +10,8 @@ import (
 	"github.com/pkg/errors"
 )
 
-var ErrInvalidImageCT = errors.New("Unknown image content-type")
+var ErrInvalidImageCT = errors.New("unknown image content-type")
-var ErrInvalidImageData = errors.New("Invalid image data")
+var ErrInvalidImageData = errors.New("invalid image data")
-var ErrNoImage = errors.New("null image")
 
 type ErrImageTooLarge struct {
 	Size, Max int

api/rate/rate.go

@@ -169,7 +169,7 @@ func (l *Limiter) Release(path string, headers http.Header) error {
 	case retryAfter != "":
 		i, err := strconv.Atoi(retryAfter)
 		if err != nil {
-			return errors.Wrap(err, "Invalid retryAfter "+retryAfter)
+			return errors.Wrap(err, "invalid retryAfter "+retryAfter)
 		}
 
 		at := time.Now().Add(time.Duration(i) * time.Millisecond)
@@ -183,7 +183,7 @@ func (l *Limiter) Release(path string, headers http.Header) error {
 	case reset != "":
 		unix, err := strconv.ParseFloat(reset, 64)
 		if err != nil {
-			return errors.Wrap(err, "Invalid reset "+reset)
+			return errors.Wrap(err, "invalid reset "+reset)
 		}
 
 		b.reset = time.Unix(0, int64(unix*float64(time.Second))).
@@ -193,7 +193,7 @@ func (l *Limiter) Release(path string, headers http.Header) error {
 	if remaining != "" {
 		u, err := strconv.ParseUint(remaining, 10, 64)
 		if err != nil {
-			return errors.Wrap(err, "Invalid remaining "+remaining)
+			return errors.Wrap(err, "invalid remaining "+remaining)
 		}
 
 		b.remaining = u

api/rate/rate_test.go

@@ -46,7 +46,7 @@ func TestRatelimitReset(t *testing.T) {
 	if time.Since(sent) >= time.Second && time.Since(sent) < time.Second*4 {
 		t.Log("OK", time.Since(sent))
 	} else {
-		t.Error("Did not ratelimit correctly, got:", time.Since(sent))
+		t.Error("did not ratelimit correctly, got:", time.Since(sent))
 	}
 }
 
@@ -71,6 +71,6 @@ func TestRatelimitGlobal(t *testing.T) {
 	if time.Since(sent) >= time.Second && time.Since(sent) < time.Second*2 {
 		t.Log("OK", time.Since(sent))
 	} else {
-		t.Error("Did not ratelimit correctly, got:", time.Since(sent))
+		t.Error("did not ratelimit correctly, got:", time.Since(sent))
 	}
 }

api/send.go

@@ -64,21 +64,21 @@ const (
 // AllowedMentions' documentation. This will be called on SendMessageComplex.
 func (am AllowedMentions) Verify() error {
 	if len(am.Roles) > 100 {
-		return errors.Errorf("Roles slice length %d is over 100", len(am.Roles))
+		return errors.Errorf("roles slice length %d is over 100", len(am.Roles))
 	}
 	if len(am.Users) > 100 {
-		return errors.Errorf("Users slice length %d is over 100", len(am.Users))
+		return errors.Errorf("users slice length %d is over 100", len(am.Users))
 	}
 
 	for _, allowed := range am.Parse {
 		switch allowed {
 		case AllowRoleMention:
 			if len(am.Roles) > 0 {
-				return errors.New(`Parse has AllowRoleMention and Roles slice is not empty`)
+				return errors.New(`parse has AllowRoleMention and Roles slice is not empty`)
 			}
 		case AllowUserMention:
 			if len(am.Users) > 0 {
-				return errors.New(`Parse has AllowUserMention and Users slice is not empty`)
+				return errors.New(`parse has AllowUserMention and Users slice is not empty`)
 			}
 		}
 	}
@@ -88,7 +88,7 @@ func (am AllowedMentions) Verify() error {
 
 // ErrEmptyMessage is returned if either a SendMessageData or an
 // ExecuteWebhookData has both an empty Content and no Embed(s).
-var ErrEmptyMessage = errors.New("Message is empty")
+var ErrEmptyMessage = errors.New("message is empty")
 
 // SendMessageFile represents a file to be uploaded to Discord.
 type SendMessageFile struct {
@@ -146,13 +146,13 @@ func (c *Client) SendMessageComplex(
 
 	if data.AllowedMentions != nil {
 		if err := data.AllowedMentions.Verify(); err != nil {
-			return nil, errors.Wrap(err, "AllowedMentions error")
+			return nil, errors.Wrap(err, "allowedMentions error")
 		}
 	}
 
 	if data.Embed != nil {
 		if err := data.Embed.Validate(); err != nil {
-			return nil, errors.Wrap(err, "Embed error")
+			return nil, errors.Wrap(err, "embed error")
 		}
 	}
 
@@ -222,13 +222,13 @@ func (c *Client) ExecuteWebhook(
 
 	if data.AllowedMentions != nil {
 		if err := data.AllowedMentions.Verify(); err != nil {
-			return nil, errors.Wrap(err, "AllowedMentions error")
+			return nil, errors.Wrap(err, "allowedMentions error")
 		}
 	}
 
 	for i, embed := range data.Embeds {
 		if err := embed.Validate(); err != nil {
-			return nil, errors.Wrap(err, "Embed error at "+strconv.Itoa(i))
+			return nil, errors.Wrap(err, "embed error at "+strconv.Itoa(i))
 		}
 	}
 
@@ -272,11 +272,11 @@ func writeMultipart(body *multipart.Writer, item interface{}, files []SendMessag
 	// Encode the JSON body first
 	w, err := body.CreateFormField("payload_json")
 	if err != nil {
-		return errors.Wrap(err, "Failed to create bodypart for JSON")
+		return errors.Wrap(err, "failed to create bodypart for JSON")
 	}
 
 	if err := json.EncodeStream(w, item); err != nil {
-		return errors.Wrap(err, "Failed to encode JSON")
+		return errors.Wrap(err, "failed to encode JSON")
 	}
 
 	for i, file := range files {
@@ -284,11 +284,11 @@ func writeMultipart(body *multipart.Writer, item interface{}, files []SendMessag
 
 		w, err := body.CreateFormFile("file"+num, file.Name)
 		if err != nil {
-			return errors.Wrap(err, "Failed to create bodypart for "+num)
+			return errors.Wrap(err, "failed to create bodypart for "+num)
 		}
 
 		if _, err := io.Copy(w, file.Reader); err != nil {
-			return errors.Wrap(err, "Failed to write for file "+num)
+			return errors.Wrap(err, "failed to write for file "+num)
 		}
 	}
 

api/send_test.go

@@ -61,7 +61,7 @@ func TestVerifyAllowedMentions(t *testing.T) {
 		}
 
 		err := am.Verify()
-		errMustContain(t, err, "Users slice length 101 is over 100")
+		errMustContain(t, err, "users slice length 101 is over 100")
 	})
 
 	t.Run("roles too long", func(t *testing.T) {
@@ -70,7 +70,7 @@ func TestVerifyAllowedMentions(t *testing.T) {
 		}
 
 		err := am.Verify()
-		errMustContain(t, err, "Roles slice length 101 is over 100")
+		errMustContain(t, err, "roles slice length 101 is over 100")
 	})
 
 	t.Run("valid", func(t *testing.T) {
@@ -130,7 +130,7 @@ func TestSendMessage(t *testing.T) {
 		}
 
 		err := send(data)
-		errMustContain(t, err, "AllowedMentions error")
+		errMustContain(t, err, "allowedMentions error")
 	})
 
 	t.Run("invalid embed", func(t *testing.T) {
@@ -142,7 +142,7 @@ func TestSendMessage(t *testing.T) {
 		}
 
 		err := send(data)
-		errMustContain(t, err, "Embed error")
+		errMustContain(t, err, "embed error")
 	})
 }
 

bot/command.go

@@ -149,7 +149,7 @@ func parseMethod(value reflect.Value, method reflect.Method) *MethodContext {
 			t := methodT.In(i)
 			a, err := newArgument(t, command.Variadic)
 			if err != nil {
-				panic("Error parsing argument " + t.String() + ": " + err.Error())
+				panic("error parsing argument " + t.String() + ": " + err.Error())
 			}
 
 			command.Arguments = append(command.Arguments, *a)
@@ -228,7 +228,7 @@ func ParseMiddleware(mw interface{}) *MiddlewareContext {
 	// Check the last return's type if the method returns anything.
 	if numOut == 1 {
 		if i := methodT.Out(0); i == nil || !i.Implements(typeIError) {
-			panic("Unexpected return type (not error) for " + methodT.String())
+			panic("unexpected return type (not error) for " + methodT.String())
 		}
 	}
 

bot/ctx.go

@@ -145,12 +145,12 @@ func Start(token string, cmd interface{},
 
 	s, err := state.New("Bot " + token)
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to create a dgo session")
+		return nil, errors.Wrap(err, "failed to create a dgo session")
 	}
 
 	c, err := New(s, cmd)
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to create rfrouter")
+		return nil, errors.Wrap(err, "failed to create rfrouter")
 	}
 
 	s.Gateway.ErrorLog = func(err error) {
@@ -166,7 +166,7 @@ func Start(token string, cmd interface{},
 	cancel := c.Start()
 
 	if err := s.Open(); err != nil {
-		return nil, errors.Wrap(err, "Failed to connect to Discord")
+		return nil, errors.Wrap(err, "failed to connect to Discord")
 	}
 
 	return func() error {
@@ -221,7 +221,7 @@ func New(s *state.State, cmd interface{}) (*Context, error) {
 	}
 
 	if err := ctx.InitCommands(ctx); err != nil {
-		return nil, errors.Wrap(err, "Failed to initialize with given cmds")
+		return nil, errors.Wrap(err, "failed to initialize with given cmds")
 	}
 
 	return ctx, nil
@@ -282,7 +282,7 @@ func (ctx *Context) RegisterSubcommand(cmd interface{}) (*Subcommand, error) {
 func (ctx *Context) RegisterSubcommandCustom(cmd interface{}, name string) (*Subcommand, error) {
 	s, err := NewSubcommand(cmd)
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to add subcommand")
+		return nil, errors.Wrap(err, "failed to add subcommand")
 	}
 
 	// Register the subcommand's name.
@@ -293,13 +293,13 @@ func (ctx *Context) RegisterSubcommandCustom(cmd interface{}, name string) (*Sub
 	}
 
 	if err := s.InitCommands(ctx); err != nil {
-		return nil, errors.Wrap(err, "Failed to initialize subcommand")
+		return nil, errors.Wrap(err, "failed to initialize subcommand")
 	}
 
 	// Do a collision check
 	for _, sub := range ctx.subcommands {
 		if sub.Command == s.Command {
-			return nil, errors.New("New subcommand has duplicate name: " + s.Command)
+			return nil, errors.New("new subcommand has duplicate name: " + s.Command)
 		}
 	}
 
@@ -332,7 +332,7 @@ func (ctx *Context) Start() func() {
 			case *ErrInvalidUsage, *ErrUnknownCommand:
 				// Ignore
 			default:
-				ctx.ErrorLogger(errors.Wrap(err, "Command error"))
+				ctx.ErrorLogger(errors.Wrap(err, "command error"))
 			}
 
 			return

bot/ctx_call.go

@@ -127,7 +127,7 @@ func (ctx *Context) callMessageCreate(mc *gateway.MessageCreateEvent, value refl
 	// parse arguments
 	parts, err := ctx.ParseArgs(content)
 	if err != nil {
-		return errors.Wrap(err, "Failed to parse command")
+		return errors.Wrap(err, "failed to parse command")
 	}
 
 	if len(parts) == 0 {

bot/ctx_test.go

@@ -254,7 +254,7 @@ func TestContext(t *testing.T) {
 
 		err := testMessage("joe pls no")
 
-		if err == nil || !strings.HasPrefix(err.Error(), "Unknown command:") {
+		if err == nil || !strings.HasPrefix(err.Error(), "unknown command:") {
 			t.Fatal("unexpected error:", err)
 		}
 	})
@@ -350,7 +350,7 @@ func sendMsg(ctx *Context, given *testc, into interface{}, content string) (call
 		return fmt.Errorf("expected return before error: %w", call)
 
 	case <-time.After(time.Second):
-		return errors.New("Timed out while waiting")
+		return errors.New("timed out while waiting")
 	}
 }
 

bot/error.go

@@ -18,12 +18,12 @@ func (err *ErrUnknownCommand) Error() string {
 }
 
 var UnknownCommandString = func(err *ErrUnknownCommand) string {
-	return "Unknown command: " + strings.Join(err.Parts, " ")
+	return "unknown command: " + strings.Join(err.Parts, " ")
 }
 
 var (
-	ErrTooManyArgs   = errors.New("Too many arguments given")
+	ErrTooManyArgs   = errors.New("too many arguments given")
-	ErrNotEnoughArgs = errors.New("Not enough arguments given")
+	ErrNotEnoughArgs = errors.New("not enough arguments given")
 )
 
 type ErrInvalidUsage struct {
@@ -47,11 +47,11 @@ func (err *ErrInvalidUsage) Unwrap() error {
 
 var InvalidUsageString = func(err *ErrInvalidUsage) string {
 	if err.Index == 0 && err.Wrap != nil {
-		return "Invalid usage, error: " + err.Wrap.Error() + "."
+		return "invalid usage, error: " + err.Wrap.Error() + "."
 	}
 
 	if err.Index == 0 || len(err.Args) == 0 {
-		return "Missing arguments. Refer to help."
+		return "missing arguments. Refer to help."
 	}
 
 	body := "Invalid usage at " +

bot/error_test.go

@@ -29,7 +29,7 @@ func TestInvalidUsage(t *testing.T) {
 		err := ErrInvalidUsage{}
 		str := err.Error()
 
-		if str != "Missing arguments. Refer to help." {
+		if str != "missing arguments. Refer to help." {
 			t.Fatal("Unexpected error:", str)
 		}
 	})
@@ -38,7 +38,7 @@ func TestInvalidUsage(t *testing.T) {
 		err := ErrInvalidUsage{Wrap: errors.New("astolfo")}
 		str := err.Error()
 
-		if str != "Invalid usage, error: astolfo." {
+		if str != "invalid usage, error: astolfo." {
 			t.Fatal("Unexpected error:", str)
 		}
 	})

bot/extras/arguments/emoji.go

@@ -11,7 +11,7 @@ import (
 var (
 	EmojiRegex = regexp.MustCompile(`<(a?):(.+?):(\d+)>`)
 
-	ErrInvalidEmoji = errors.New("Invalid emoji")
+	ErrInvalidEmoji = errors.New("invalid emoji")
 )
 
 type Emoji struct {

bot/extras/arguments/link.go

@@ -25,7 +25,7 @@ type MessageURL struct {
 func (url *MessageURL) Parse(arg string) error {
 	u := ParseMessageURL(arg)
 	if u == nil {
-		return errors.New("Invalid MessageURL format.")
+		return errors.New("invalid MessageURL format")
 	}
 	*url = *u
 	return nil

bot/extras/arguments/mention.go

@@ -78,12 +78,12 @@ func (m *RoleMention) Mention() string {
 func grabFirst(reg *regexp.Regexp, item, input string, output *discord.Snowflake) error {
 	matches := reg.FindStringSubmatch(input)
 	if len(matches) < 2 {
-		return errors.New("Invalid " + item)
+		return errors.New("invalid " + item)
 	}
 
 	id, err := discord.ParseSnowflake(matches[1])
 	if err != nil {
-		return errors.New("Invalid " + item)
+		return errors.New("invalid " + item)
 	}
 
 	*output = id

bot/subcommand.go

@@ -134,11 +134,11 @@ func NewSubcommand(cmd interface{}) (*Subcommand, error) {
 	}
 
 	if err := sub.reflectCommands(); err != nil {
-		return nil, errors.Wrap(err, "Failed to reflect commands")
+		return nil, errors.Wrap(err, "failed to reflect commands")
 	}
 
 	if err := sub.parseCommands(); err != nil {
-		return nil, errors.Wrap(err, "Failed to parse commands")
+		return nil, errors.Wrap(err, "failed to parse commands")
 	}
 
 	return &sub, nil
@@ -292,7 +292,7 @@ func (sub *Subcommand) fillStruct(ctx *Context) error {
 		return nil
 	}
 
-	return errors.New("No fields with *bot.Context found")
+	return errors.New("no fields with *bot.Context found")
 }
 
 func (sub *Subcommand) parseCommands() error {

discord/auditlog.go

@@ -133,10 +133,10 @@ type AuditLogChange struct {
 
 func (a AuditLogChange) UnmarshalValues(old, new interface{}) error {
 	if err := a.NewValue.UnmarshalTo(new); err != nil {
-		return errors.Wrap(err, "Failed to unmarshal old value")
+		return errors.Wrap(err, "failed to unmarshal old value")
 	}
 	if err := a.OldValue.UnmarshalTo(old); err != nil {
-		return errors.Wrap(err, "Failed to unmarshal new value")
+		return errors.Wrap(err, "failed to unmarshal new value")
 	}
 	return nil
 }

discord/message_embed.go

@@ -80,15 +80,15 @@ func (e *Embed) Validate() error {
 	}
 
 	if len(e.Title) > 256 {
-		return &ErrOverbound{len(e.Title), 256, "Title"}
+		return &ErrOverbound{len(e.Title), 256, "title"}
 	}
 
 	if len(e.Description) > 2048 {
-		return &ErrOverbound{len(e.Description), 2048, "Description"}
+		return &ErrOverbound{len(e.Description), 2048, "description"}
 	}
 
 	if len(e.Fields) > 25 {
-		return &ErrOverbound{len(e.Fields), 25, "Fields"}
+		return &ErrOverbound{len(e.Fields), 25, "fields"}
 	}
 
 	var sum = 0 +
@@ -97,7 +97,7 @@ func (e *Embed) Validate() error {
 
 	if e.Footer != nil {
 		if len(e.Footer.Text) > 2048 {
-			return &ErrOverbound{len(e.Footer.Text), 2048, "Footer text"}
+			return &ErrOverbound{len(e.Footer.Text), 2048, "footer text"}
 		}
 
 		sum += len(e.Footer.Text)
@@ -105,7 +105,7 @@ func (e *Embed) Validate() error {
 
 	if e.Author != nil {
 		if len(e.Author.Name) > 256 {
-			return &ErrOverbound{len(e.Author.Name), 256, "Author name"}
+			return &ErrOverbound{len(e.Author.Name), 256, "author name"}
 		}
 
 		sum += len(e.Author.Name)
@@ -126,7 +126,7 @@ func (e *Embed) Validate() error {
 	}
 
 	if sum > 6000 {
-		return &ErrOverbound{sum, 6000, "Sum of all characters"}
+		return &ErrOverbound{sum, 6000, "sum of all characters"}
 	}
 
 	return nil

gateway/commands.go

@@ -16,7 +16,7 @@ func (g *Gateway) Identify() error {
 	defer cancel()
 
 	if err := g.Identifier.Wait(ctx); err != nil {
-		return errors.Wrap(err, "Can't wait for identify()")
+		return errors.Wrap(err, "can't wait for identify()")
 	}
 
 	return g.Send(IdentifyOP, g.Identifier)

gateway/gateway.go

@@ -112,7 +112,7 @@ type Gateway struct {
 func NewGateway(token string) (*Gateway, error) {
 	URL, err := URL()
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to get gateway endpoint")
+		return nil, errors.Wrap(err, "failed to get gateway endpoint")
 	}
 
 	// Parameters for the gateway
@@ -200,7 +200,7 @@ func (g *Gateway) ReconnectContext(ctx context.Context) error {
 		// https://discordapp.com/developers/docs/topics/gateway#rate-limiting
 
 		if err := g.OpenContext(ctx); err != nil {
-			g.ErrorLog(errors.Wrap(err, "Failed to open gateway"))
+			g.ErrorLog(errors.Wrap(err, "failed to open gateway"))
 			continue
 		}
 
@@ -218,7 +218,7 @@ func (g *Gateway) Open() error {
 func (g *Gateway) OpenContext(ctx context.Context) error {
 	// Reconnect to the Gateway
 	if err := g.WS.Dial(ctx); err != nil {
-		return errors.Wrap(err, "Failed to reconnect")
+		return errors.Wrap(err, "failed to reconnect")
 	}
 
 	wsutil.WSDebug("Trying to start...")
@@ -262,7 +262,7 @@ func (g *Gateway) start() error {
 	// Wait for an OP 10 Hello
 	var hello HelloEvent
 	if _, err := wsutil.AssertEvent(<-ch, HelloOP, &hello); err != nil {
-		return errors.Wrap(err, "Error at Hello")
+		return errors.Wrap(err, "error at Hello")
 	}
 
 	// Send Discord either the Identify packet (if it's a fresh connection), or
@@ -270,11 +270,11 @@ func (g *Gateway) start() error {
 	if g.SessionID == "" {
 		// SessionID is empty, so this is a completely new session.
 		if err := g.Identify(); err != nil {
-			return errors.Wrap(err, "Failed to identify")
+			return errors.Wrap(err, "failed to identify")
 		}
 	} else {
 		if err := g.Resume(); err != nil {
-			return errors.Wrap(err, "Failed to resume")
+			return errors.Wrap(err, "failed to resume")
 		}
 	}
 
@@ -295,7 +295,7 @@ func (g *Gateway) start() error {
 	})
 
 	if err != nil {
-		return errors.Wrap(err, "First error")
+		return errors.Wrap(err, "first error")
 	}
 
 	// Use the pacemaker loop.
@@ -327,7 +327,7 @@ func (g *Gateway) Send(code OPCode, v interface{}) error {
 	if v != nil {
 		b, err := json.Marshal(v)
 		if err != nil {
-			return errors.Wrap(err, "Failed to encode v")
+			return errors.Wrap(err, "failed to encode v")
 		}
 
 		op.Data = b
@@ -335,7 +335,7 @@ func (g *Gateway) Send(code OPCode, v interface{}) error {
 
 	b, err := json.Marshal(op)
 	if err != nil {
-		return errors.Wrap(err, "Failed to encode payload")
+		return errors.Wrap(err, "failed to encode payload")
 	}
 
 	// WS should already be thread-safe.

gateway/identify.go

@@ -107,10 +107,10 @@ func NewIdentifier(data IdentifyData) *Identifier {
 
 func (i *Identifier) Wait(ctx context.Context) error {
 	if err := i.IdentifyShortLimit.Wait(ctx); err != nil {
-		return errors.Wrap(err, "Can't wait for short limit")
+		return errors.Wrap(err, "can't wait for short limit")
 	}
 	if err := i.IdentifyGlobalLimit.Wait(ctx); err != nil {
-		return errors.Wrap(err, "Can't wait for global limit")
+		return errors.Wrap(err, "can't wait for global limit")
 	}
 	return nil
 }

gateway/op.go

@@ -84,7 +84,7 @@ func (g *Gateway) HandleOP(op *wsutil.OP) error {
 
 		// Try and parse the event
 		if err := json.Unmarshal(op.Data, ev); err != nil {
-			return errors.Wrap(err, "Failed to parse event "+op.EventName)
+			return errors.Wrap(err, "failed to parse event "+op.EventName)
 		}
 
 		// If the event is a ready, we'll want its sessionID
@@ -97,7 +97,7 @@ func (g *Gateway) HandleOP(op *wsutil.OP) error {
 		return nil
 
 	default:
-		return fmt.Errorf("Unknown OP code %d (event %s)", op.Code, op.EventName)
+		return fmt.Errorf("unknown OP code %d (event %s)", op.Code, op.EventName)
 	}
 
 	return nil

handler/handler.go

@@ -157,7 +157,7 @@ func (h *Handler) addHandler(fn interface{}) (rm func(), err error) {
 	// Reflect the handler
 	r, err := reflectFn(fn)
 	if err != nil {
-		return nil, errors.Wrap(err, "Handler reflect failed")
+		return nil, errors.Wrap(err, "handler reflect failed")
 	}
 
 	h.hmutex.Lock()

session/session.go

@@ -22,7 +22,7 @@ type Closed struct {
 	Error error
 }
 
-var ErrMFA = errors.New("Account has 2FA enabled")
+var ErrMFA = errors.New("account has 2FA enabled")
 
 // Session manages both the API and Gateway. As such, Session inherits all of
 // API's methods, as well has the Handler used for Gateway.
@@ -49,7 +49,7 @@ func New(token string) (*Session, error) {
 	// Create a gateway
 	g, err := gateway.NewGateway(token)
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to connect to Gateway")
+		return nil, errors.Wrap(err, "failed to connect to Gateway")
 	}
 	s.Gateway = g
 
@@ -64,7 +64,7 @@ func Login(email, password, mfa string) (*Session, error) {
 	// Try to login without TOTP
 	l, err := client.Login(email, password)
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to login")
+		return nil, errors.Wrap(err, "failed to login")
 	}
 
 	if l.Token != "" && !l.MFA {
@@ -80,7 +80,7 @@ func Login(email, password, mfa string) (*Session, error) {
 	// Retry logging in with a 2FA token
 	l, err = client.TOTP(mfa, l.Ticket)
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to login with 2FA")
+		return nil, errors.Wrap(err, "failed to login with 2FA")
 	}
 
 	return New(l.Token)
@@ -109,7 +109,7 @@ func (s *Session) Open() error {
 	}
 
 	if err := s.Gateway.Open(); err != nil {
-		return errors.Wrap(err, "Failed to start gateway")
+		return errors.Wrap(err, "failed to start gateway")
 	}
 
 	return nil

state/state.go

@@ -171,7 +171,7 @@ func (s *State) MemberColor(guildID, userID discord.Snowflake) (discord.Color, e
 func (s *State) Permissions(channelID, userID discord.Snowflake) (discord.Permissions, error) {
 	ch, err := s.Channel(channelID)
 	if err != nil {
-		return 0, errors.Wrap(err, "Failed to get channel")
+		return 0, errors.Wrap(err, "failed to get channel")
 	}
 
 	var wg sync.WaitGroup

state/state_events.go

@@ -29,7 +29,7 @@ func (s *State) onEvent(iface interface{}) {
 			p := p
 
 			if err := s.Store.PresenceSet(0, &p); err != nil {
-				s.stateErr(err, "Failed to set global presence")
+				s.stateErr(err, "failed to set global presence")
 			}
 		}
 
@@ -41,13 +41,13 @@ func (s *State) onEvent(iface interface{}) {
 		// Handle private channels
 		for i := range ev.PrivateChannels {
 			if err := s.Store.ChannelSet(&ev.PrivateChannels[i]); err != nil {
-				s.stateErr(err, "Failed to set channel in state")
+				s.stateErr(err, "failed to set channel in state")
 			}
 		}
 
 		// Handle user
 		if err := s.Store.MyselfSet(&ev.User); err != nil {
-			s.stateErr(err, "Failed to set self in state")
+			s.stateErr(err, "failed to set self in state")
 		}
 
 	case *gateway.GuildCreateEvent:
@@ -55,17 +55,17 @@ func (s *State) onEvent(iface interface{}) {
 
 	case *gateway.GuildUpdateEvent:
 		if err := s.Store.GuildSet((*discord.Guild)(ev)); err != nil {
-			s.stateErr(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.stateErr(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.stateErr(err, "Failed to add a member in state")
+			s.stateErr(err, "failed to add a member in state")
 		}
 
 	case *gateway.GuildMemberUpdateEvent:
@@ -79,12 +79,12 @@ func (s *State) onEvent(iface interface{}) {
 		ev.Update(m)
 
 		if err := s.Store.MemberSet(ev.GuildID, m); err != nil {
-			s.stateErr(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.stateErr(err, "Failed to remove a member in state")
+			s.stateErr(err, "failed to remove a member in state")
 		}
 
 	case *gateway.GuildMembersChunkEvent:
@@ -92,7 +92,7 @@ func (s *State) onEvent(iface interface{}) {
 			m := m
 
 			if err := s.Store.MemberSet(ev.GuildID, &m); err != nil {
-				s.stateErr(err, "Failed to add a member from chunk in state")
+				s.stateErr(err, "failed to add a member from chunk in state")
 			}
 		}
 
@@ -100,43 +100,43 @@ func (s *State) onEvent(iface interface{}) {
 			p := p
 
 			if err := s.Store.PresenceSet(ev.GuildID, &p); err != nil {
-				s.stateErr(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.stateErr(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.stateErr(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.stateErr(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.stateErr(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.stateErr(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.stateErr(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.stateErr(err, "Failed to remove a channel in state")
+			s.stateErr(err, "failed to remove a channel in state")
 		}
 
 	case *gateway.ChannelPinsUpdateEvent:
@@ -144,23 +144,23 @@ func (s *State) onEvent(iface interface{}) {
 
 	case *gateway.MessageCreateEvent:
 		if err := s.Store.MessageSet(&ev.Message); err != nil {
-			s.stateErr(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(&ev.Message); err != nil {
-			s.stateErr(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.stateErr(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.stateErr(err, "Failed to delete bulk meessages in state")
+				s.stateErr(err, "failed to delete bulk meessages in state")
 			}
 		}
 
@@ -225,7 +225,7 @@ func (s *State) onEvent(iface interface{}) {
 
 	case *gateway.PresenceUpdateEvent:
 		if err := s.Store.PresenceSet(ev.GuildID, &ev.Presence); err != nil {
-			s.stateErr(err, "Failed to update presence in state")
+			s.stateErr(err, "failed to update presence in state")
 		}
 
 	case *gateway.PresencesReplaceEvent:
@@ -233,7 +233,7 @@ func (s *State) onEvent(iface interface{}) {
 			p := (*ev)[i]
 
 			if err := s.Store.PresenceSet(p.GuildID, &p); err != nil {
-				s.stateErr(err, "Failed to update presence in state")
+				s.stateErr(err, "failed to update presence in state")
 			}
 		}
 
@@ -254,18 +254,18 @@ func (s *State) onEvent(iface interface{}) {
 
 	case *gateway.UserUpdateEvent:
 		if err := s.Store.MyselfSet(&ev.User); err != nil {
-			s.stateErr(err, "Failed to update myself from USER_UPDATE")
+			s.stateErr(err, "failed to update myself from USER_UPDATE")
 		}
 
 	case *gateway.VoiceStateUpdateEvent:
 		vs := &ev.VoiceState
 		if vs.ChannelID == 0 {
 			if err := s.Store.VoiceStateRemove(vs.GuildID, vs.UserID); err != nil {
-				s.stateErr(err, "Failed to remove voice state from state")
+				s.stateErr(err, "failed to remove voice state from state")
 			}
 		} else {
 			if err := s.Store.VoiceStateSet(vs.GuildID, vs); err != nil {
-				s.stateErr(err, "Failed to update voice state in state")
+				s.stateErr(err, "failed to update voice state in state")
 			}
 		}
 	}
@@ -291,7 +291,7 @@ func (s *State) editMessage(ch, msg discord.Snowflake, fn func(m *discord.Messag
 		return
 	}
 	if err := s.Store.MessageSet(m); err != nil {
-		s.stateErr(err, "Failed to save message in reaction add")
+		s.stateErr(err, "failed to save message in reaction add")
 	}
 }
 
@@ -314,41 +314,41 @@ func handleGuildCreate(store Store, guild *gateway.GuildCreateEvent) []error {
 	stack, error := newErrorStack()
 
 	if err := store.GuildSet(&guild.Guild); err != nil {
-		error(err, "Failed to set guild in Ready")
+		error(err, "failed to set guild in Ready")
 	}
 
 	// Handle guild emojis
 	if guild.Emojis != nil {
 		if err := store.EmojiSet(guild.ID, guild.Emojis); err != nil {
-			error(err, "Failed to set guild emojis")
+			error(err, "failed to set guild emojis")
 		}
 	}
 
 	// Handle guild member
 	for i := range guild.Members {
 		if err := store.MemberSet(guild.ID, &guild.Members[i]); err != nil {
-			error(err, "Failed to set guild member in Ready")
+			error(err, "failed to set guild member in Ready")
 		}
 	}
 
 	// Handle guild channels
 	for i := range guild.Channels {
 		if err := store.ChannelSet(&guild.Channels[i]); err != nil {
-			error(err, "Failed to set guild channel in Ready")
+			error(err, "failed to set guild channel in Ready")
 		}
 	}
 
 	// Handle guild presences
 	for i := range guild.Presences {
 		if err := store.PresenceSet(guild.ID, &guild.Presences[i]); err != nil {
-			error(err, "Failed to set guild presence in Ready")
+			error(err, "failed to set guild presence in Ready")
 		}
 	}
 
 	// Handle guild voice states
 	for i := range guild.VoiceStates {
 		if err := store.VoiceStateSet(guild.ID, &guild.VoiceStates[i]); err != nil {
-			error(err, "Failed to set guild voice state in Ready")
+			error(err, "failed to set guild voice state in Ready")
 		}
 	}
 

state/store_noop.go

@@ -13,7 +13,7 @@ type NoopStore struct{}
 
 var _ Store = (*NoopStore)(nil)
 
-var ErrNotImplemented = errors.New("State is not implemented")
+var ErrNotImplemented = errors.New("state is not implemented")
 
 func (NoopStore) Reset() error {
 	return nil

utils/httputil/client.go

@@ -165,7 +165,7 @@ func (c *Client) Request(method, url string, opts ...RequestOption) (httpdriver.
 		}
 
 		if err := c.applyOptions(q, opts); err != nil {
-			return nil, errors.Wrap(err, "Failed to apply options")
+			return nil, errors.Wrap(err, "failed to apply options")
 		}
 
 		r, doErr = c.Client.Do(q)

utils/httputil/errors.go

@@ -22,7 +22,7 @@ type RequestError struct {
 }
 
 func (r RequestError) Error() string {
-	return "Request failed: " + r.err.Error()
+	return "request failed: " + r.err.Error()
 }
 
 func (r RequestError) Unwrap() error {

utils/wsutil/conn.go

@@ -20,7 +20,7 @@ const CopyBufferSize = 2048
 var CloseDeadline = time.Second
 
 // ErrWebsocketClosed is returned if the websocket is already closed.
-var ErrWebsocketClosed = errors.New("Websocket is closed.")
+var ErrWebsocketClosed = errors.New("websocket is closed")
 
 // Connection is an interface that abstracts around a generic Websocket driver.
 // This connection expects the driver to handle compression by itself, including
@@ -99,7 +99,7 @@ func (c *Conn) Dial(ctx context.Context, addr string) error {
 
 	c.Conn, _, err = c.dialer.DialContext(ctx, addr, headers)
 	if err != nil {
-		return errors.Wrap(err, "Failed to dial WS")
+		return errors.Wrap(err, "failed to dial WS")
 	}
 
 	// Set up the closer.
@@ -191,12 +191,12 @@ func (c *Conn) handle() ([]byte, error) {
 		if c.zlib == nil {
 			z, err := zlib.NewReader(r)
 			if err != nil {
-				return nil, errors.Wrap(err, "Failed to create a zlib reader")
+				return nil, errors.Wrap(err, "failed to create a zlib reader")
 			}
 			c.zlib = z
 		} else {
 			if err := c.zlib.(zlib.Resetter).Reset(r, nil); err != nil {
-				return nil, errors.Wrap(err, "Failed to reset zlib reader")
+				return nil, errors.Wrap(err, "failed to reset zlib reader")
 			}
 		}
 

utils/wsutil/heart.go

@@ -85,7 +85,7 @@ func (p *PacemakerLoop) startLoop() error {
 		select {
 		case err := <-p.pacedeath:
 			WSDebug("Pacedeath returned with error:", err)
-			return errors.Wrap(err, "Pacemaker died, reconnecting")
+			return errors.Wrap(err, "pacemaker died, reconnecting")
 
 		case ev, ok := <-p.events:
 			if !ok {
@@ -99,7 +99,7 @@ func (p *PacemakerLoop) startLoop() error {
 
 			o, err := DecodeOP(ev)
 			if err != nil {
-				return errors.Wrap(err, "Failed to decode OP")
+				return errors.Wrap(err, "failed to decode OP")
 			}
 
 			// Check the events before handling.
@@ -107,7 +107,7 @@ func (p *PacemakerLoop) startLoop() error {
 
 			// Handle the event
 			if err := p.handler(o); err != nil {
-				p.errorLog(errors.Wrap(err, "Handler failed"))
+				p.errorLog(errors.Wrap(err, "handler failed"))
 			}
 		}
 	}

utils/wsutil/op.go

@@ -9,7 +9,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-var ErrEmptyPayload = errors.New("Empty payload")
+var ErrEmptyPayload = errors.New("empty payload")
 
 // OPCode is a generic type for websocket OP codes.
 type OPCode uint8
@@ -58,7 +58,7 @@ func AssertEvent(ev Event, code OPCode, v interface{}) (*OP, error) {
 	}
 
 	if err := json.Unmarshal(op.Data, v); err != nil {
-		return op, errors.Wrap(err, "Failed to decode data")
+		return op, errors.Wrap(err, "failed to decode data")
 	}
 
 	return op, nil
@@ -100,7 +100,7 @@ func WaitForEvent(h EventHandler, ch <-chan Event, fn func(*OP) bool) error {
 		}
 	}
 
-	return errors.New("Event not found and event channel is closed.")
+	return errors.New("event not found and event channel is closed")
 }
 
 type ExtraHandlers struct {

utils/wsutil/ws.go

@@ -75,11 +75,11 @@ func (ws *Websocket) Dial(ctx context.Context) error {
 
 	if err := ws.DialLimiter.Wait(ctx); err != nil {
 		// Expired, fatal error
-		return errors.Wrap(err, "Failed to wait")
+		return errors.Wrap(err, "failed to wait")
 	}
 
 	if err := ws.Conn.Dial(ctx, ws.Addr); err != nil {
-		return errors.Wrap(err, "Failed to dial")
+		return errors.Wrap(err, "failed to dial")
 	}
 
 	// Reset the SendLimiter:

utils/zlib/zlib.go

@@ -61,14 +61,14 @@ func (i *Inflator) Flush() ([]byte, error) {
 	if i.zlib == nil {
 		r, err := zlibStreamer(&i.wbuf)
 		if err != nil {
-			return nil, errors.Wrap(err, "Failed to make a FLATE reader")
+			return nil, errors.Wrap(err, "failed to make a FLATE reader")
 		}
 		// safe assertion
 		i.zlib = r
 		// } else {
 		// 	// Reset the FLATE reader for future use:
 		// 	if err := i.zlib.Reset(&i.wbuf, nil); err != nil {
-		// 		return nil, errors.Wrap(err, "Failed to reset zlib reader")
+		// 		return nil, errors.Wrap(err, "failed to reset zlib reader")
 		// 	}
 	}
 
@@ -79,12 +79,12 @@ func (i *Inflator) Flush() ([]byte, error) {
 	// to verify checksum. Discord doesn't send this.
 	if err != nil {
 		// Unexpected error, try and close.
-		return nil, errors.Wrap(err, "Failed to read from FLATE reader")
+		return nil, errors.Wrap(err, "failed to read from FLATE reader")
 	}
 
 	// 	if err := i.zlib.Close(); err != nil && err != io.ErrUnexpectedEOF {
 	// 		// Try and close anyway.
-	// 		return nil, errors.Wrap(err, "Failed to read from zlib reader")
+	// 		return nil, errors.Wrap(err, "failed to read from zlib reader")
 	// 	}
 
 	// Copy the bytes.
@@ -105,7 +105,7 @@ func (i *Inflator) Flush() ([]byte, error) {
 // 	if d.zlib == nil {
 // 		r, err := zlib.NewReader(&d.wbuf)
 // 		if err != nil {
-// 			return nil, errors.Wrap(err, "Failed to make a zlib reader")
+// 			return nil, errors.Wrap(err, "failed to make a zlib reader")
 // 		}
 // 		// safe assertion
 // 		d.zlib = r
@@ -125,12 +125,12 @@ func (i *Inflator) Flush() ([]byte, error) {
 // 	// to verify checksum. Discord doesn't send this.
 // 	// if err != nil && err != io.ErrUnexpectedEOF {
 // 	// 	// Unexpected error, try and close.
-// 	// 	return nil, errors.Wrap(err, "Failed to read from zlib reader")
+// 	// 	return nil, errors.Wrap(err, "failed to read from zlib reader")
 // 	// }
 
 // 	if err := d.zlib.Close(); err != nil && err != io.ErrUnexpectedEOF {
 // 		// Try and close anyway.
-// 		return nil, errors.Wrap(err, "Failed to read from zlib reader")
+// 		return nil, errors.Wrap(err, "failed to read from zlib reader")
 // 	}
 
 // 	// Copy the bytes.

voice/session.go

@@ -74,7 +74,7 @@ func (s *Session) UpdateServer(ev *gateway.VoiceServerUpdateEvent) {
 	s.state.Token = ev.Token
 
 	if err := s.reconnect(); err != nil {
-		s.ErrorLog(errors.Wrap(err, "Failed to reconnect after voice server update"))
+		s.ErrorLog(errors.Wrap(err, "failed to reconnect after voice server update"))
 	}
 }
 
@@ -129,7 +129,7 @@ func (s *Session) JoinChannel(gID, cID discord.Snowflake, muted, deafened bool)
 		SelfDeaf:  deafened,
 	})
 	if err != nil {
-		return errors.Wrap(err, "Failed to send Voice State Update event")
+		return errors.Wrap(err, "failed to send Voice State Update event")
 	}
 
 	// Wait for replies. The above command should reply with these 2 events.
@@ -149,7 +149,7 @@ func (s *Session) reconnect() (err error) {
 
 	// Open the voice gateway. The function will block until Ready is received.
 	if err := s.gateway.Open(); err != nil {
-		return errors.Wrap(err, "Failed to open voice gateway")
+		return errors.Wrap(err, "failed to open voice gateway")
 	}
 
 	// Get the Ready event.
@@ -158,7 +158,7 @@ func (s *Session) reconnect() (err error) {
 	// Prepare the UDP voice connection.
 	s.voiceUDP, err = udp.DialConnection(voiceReady.Addr(), voiceReady.SSRC)
 	if err != nil {
-		return errors.Wrap(err, "Failed to open voice UDP connection")
+		return errors.Wrap(err, "failed to open voice UDP connection")
 	}
 
 	// Get the session description from the voice gateway.
@@ -171,7 +171,7 @@ func (s *Session) reconnect() (err error) {
 		},
 	})
 	if err != nil {
-		return errors.Wrap(err, "Failed to select protocol")
+		return errors.Wrap(err, "failed to select protocol")
 	}
 
 	// Start the UDP loop.
@@ -194,7 +194,7 @@ func (s *Session) StopSpeaking() error {
 	// Send 5 frames of silence.
 	for i := 0; i < 5; i++ {
 		if _, err := s.Write(OpusSilence[:]); err != nil {
-			return errors.Wrapf(err, "Failed to send frame %d", i)
+			return errors.Wrapf(err, "failed to send frame %d", i)
 		}
 	}
 	return nil
@@ -232,7 +232,7 @@ func (s *Session) Disconnect() error {
 
 	s.ensureClosed()
 	// wrap returns nil if err is nil
-	return errors.Wrap(err, "Failed to update voice state")
+	return errors.Wrap(err, "failed to update voice state")
 }
 
 // close ensures everything is closed. It does not acquire the mutex.

voice/udp/udp.go

@@ -33,13 +33,13 @@ func DialConnection(addr string, ssrc uint32) (*Connection, error) {
 	// Resolve the host.
 	a, err := net.ResolveUDPAddr("udp", addr)
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to resolve host")
+		return nil, errors.Wrap(err, "failed to resolve host")
 	}
 
 	// Create a new UDP connection.
 	conn, err := net.DialUDP("udp", nil, a)
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to dial host")
+		return nil, errors.Wrap(err, "failed to dial host")
 	}
 
 	// https://discordapp.com/developers/docs/topics/voice-connections#ip-discovery
@@ -51,7 +51,7 @@ func DialConnection(addr string, ssrc uint32) (*Connection, error) {
 
 	_, err = conn.Write(ssrcBuffer[:])
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to write SSRC buffer")
+		return nil, errors.Wrap(err, "failed to write SSRC buffer")
 	}
 
 	var ipBuffer [70]byte
@@ -59,7 +59,7 @@ func DialConnection(addr string, ssrc uint32) (*Connection, error) {
 	// ReadFull makes sure to read all 70 bytes.
 	_, err = io.ReadFull(conn, ipBuffer[:])
 	if err != nil {
-		return nil, errors.Wrap(err, "Failed to read IP buffer")
+		return nil, errors.Wrap(err, "failed to read IP buffer")
 	}
 
 	ipbody := ipBuffer[4:68]

voice/voice.go

@@ -17,7 +17,7 @@ import (
 
 var (
 	// defaultErrorHandler is the default error handler
-	defaultErrorHandler = func(err error) { log.Println("Voice gateway error:", err) }
+	defaultErrorHandler = func(err error) { log.Println("voice gateway error:", err) }
 
 	// ErrCannotSend is an error when audio is sent to a closed channel.
 	ErrCannotSend = errors.New("cannot send audio to closed channel")
@@ -125,7 +125,7 @@ func (v *Voice) JoinChannel(gID, cID discord.Snowflake, muted, deafened bool) (*
 	if !ok {
 		u, err := v.Me()
 		if err != nil {
-			return nil, errors.Wrap(err, "Failed to get self")
+			return nil, errors.Wrap(err, "failed to get self")
 		}
 
 		conn = NewSession(v.Session, u.ID)

voice/voicegateway/gateway.go

@@ -99,7 +99,7 @@ func (c *Gateway) Open() error {
 
 	// Connect to the Gateway Gateway.
 	if err := c.ws.Dial(ctx); err != nil {
-		return errors.Wrap(err, "Failed to connect to voice gateway")
+		return errors.Wrap(err, "failed to connect to voice gateway")
 	}
 
 	wsutil.WSDebug("Trying to start...")
@@ -141,7 +141,7 @@ func (c *Gateway) __start() error {
 	var hello *HelloEvent
 	_, err := wsutil.AssertEvent(<-ch, HelloOP, &hello)
 	if err != nil {
-		return errors.Wrap(err, "Error at Hello")
+		return errors.Wrap(err, "error at Hello")
 	}
 
 	wsutil.WSDebug("Received Hello")
@@ -150,11 +150,11 @@ func (c *Gateway) __start() error {
 	// Turns out Hello is sent right away on connection start.
 	if !c.reconnect.Get() {
 		if err := c.Identify(); err != nil {
-			return errors.Wrap(err, "Failed to identify")
+			return errors.Wrap(err, "failed to identify")
 		}
 	} else {
 		if err := c.Resume(); err != nil {
-			return errors.Wrap(err, "Failed to resume")
+			return errors.Wrap(err, "failed to resume")
 		}
 	}
 	// This bool is because we should only try and Resume once.
@@ -165,7 +165,7 @@ func (c *Gateway) __start() error {
 		return op.Code == ReadyOP || op.Code == ResumedOP
 	})
 	if err != nil {
-		return errors.Wrap(err, "Failed to wait for Ready or Resumed")
+		return errors.Wrap(err, "failed to wait for Ready or Resumed")
 	}
 
 	// Create an event loop executor.
@@ -240,7 +240,7 @@ func (c *Gateway) Reconnect() error {
 	// https://discordapp.com/developers/docs/topics/gateway#rate-limiting
 
 	if err := c.Open(); err != nil {
-		return errors.Wrap(err, "Failed to reopen gateway")
+		return errors.Wrap(err, "failed to reopen gateway")
 	}
 
 	wsutil.WSDebug("Reconnected successfully.")
@@ -263,7 +263,7 @@ func (c *Gateway) SessionDescription(sp SelectProtocol) (*SessionDescriptionEven
 
 	// Wait for SessionDescriptionOP packet.
 	if err := (<-ch).UnmarshalData(&sesdesc); err != nil {
-		return nil, errors.Wrap(err, "Failed to unmarshal session description")
+		return nil, errors.Wrap(err, "failed to unmarshal session description")
 	}
 
 	return sesdesc, nil
@@ -291,7 +291,7 @@ func (c *Gateway) send(code OPCode, v interface{}) error {
 	if v != nil {
 		b, err := json.Marshal(v)
 		if err != nil {
-			return errors.Wrap(err, "Failed to encode v")
+			return errors.Wrap(err, "failed to encode v")
 		}
 
 		op.Data = b
@@ -299,7 +299,7 @@ func (c *Gateway) send(code OPCode, v interface{}) error {
 
 	b, err := json.Marshal(op)
 	if err != nil {
-		return errors.Wrap(err, "Failed to encode payload")
+		return errors.Wrap(err, "failed to encode payload")
 	}
 
 	// WS should already be thread-safe.

voice/voicegateway/op.go

@@ -31,7 +31,7 @@ func (c *Gateway) HandleOP(op *wsutil.OP) error {
 	// Gives information required to make a UDP connection
 	case ReadyOP:
 		if err := unmarshalMutex(op.Data, &c.ready, &c.mutex); err != nil {
-			return errors.Wrap(err, "Failed to parse READY event")
+			return errors.Wrap(err, "failed to parse READY event")
 		}
 
 	// Gives information about the encryption mode and secret key for sending voice packets