Normalize Log Message Strings

The general style for errors, warnings and info messages is to start
with a capitalized letter and end without a period. The main exception
is when dealing with nouns that are clearer with special case handling,
e.g. "macOS failed to work" or "ioctl is borked".

21 files changed, 197 insertions, 192 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 21a97e55..25a593b5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Log messages are now consistent in style, and some have been removed
 - Windows configuration location has been moved from %USERPROFILE%\alacritty.yml
     to %APPDATA%\alacritty\alacritty.yml
 - Windows default shell is now PowerShell instead of cmd
diff --git a/copypasta/src/windows.rs b/copypasta/src/windows.rs
index 8ec783b2..95e3db55 100644
--- a/copypasta/src/windows.rs
+++ b/copypasta/src/windows.rs
@@ -13,7 +13,7 @@ pub enum Error {
 impl ::std::error::Error for Error {
     fn description(&self) -> &str {
         match *self {
-            Error::Clipboard(..) => "error opening clipboard",
+            Error::Clipboard(..) => "Error opening clipboard",
         }
     }
 }
diff --git a/copypasta/src/x11.rs b/copypasta/src/x11.rs
index 4c58c0a4..c7d9c696 100644
--- a/copypasta/src/x11.rs
+++ b/copypasta/src/x11.rs
@@ -35,9 +35,9 @@ impl ::std::error::Error for Error {
 
     fn description(&self) -> &str {
         match *self {
-            Error::Io(..) => "error calling xclip",
-            Error::Xclip(..) => "error reported by xclip",
-            Error::Utf8(..) => "clipboard contents not utf8",
+            Error::Io(..) => "Error calling xclip",
+            Error::Xclip(..) => "Error reported by xclip",
+            Error::Utf8(..) => "Clipboard contents not utf8",
         }
     }
 }
@@ -50,11 +50,11 @@ impl ::std::fmt::Display for Error {
                     io::ErrorKind::NotFound => {
                         write!(f, "Please install `xclip` to enable clipboard support")
                     },
-                    _ => write!(f, "error calling xclip: {}", err),
+                    _ => write!(f, "Error calling xclip: {}", err),
                 }
             },
-            Error::Xclip(ref s) => write!(f, "error from xclip: {}", s),
-            Error::Utf8(ref err) => write!(f, "error parsing xclip output: {}", err),
+            Error::Xclip(ref s) => write!(f, "Error from xclip: {}", s),
+            Error::Utf8(ref err) => write!(f, "Error parsing xclip output: {}", err),
         }
     }
 }
diff --git a/font/src/darwin/mod.rs b/font/src/darwin/mod.rs
index 0e694f16..60b1a3e7 100644
--- a/font/src/darwin/mod.rs
+++ b/font/src/darwin/mod.rs
@@ -101,9 +101,9 @@ pub enum Error {
 impl ::std::error::Error for Error {
     fn description(&self) -> &str {
         match *self {
-            Error::MissingGlyph(ref _c) => "couldn't find the requested glyph",
-            Error::MissingFont(ref _desc) => "couldn't find the requested font",
-            Error::FontNotLoaded => "tried to operate on font that hasn't been loaded",
+            Error::MissingGlyph(ref _c) => "Couldn't find the requested glyph",
+            Error::MissingFont(ref _desc) => "Couldn't find the requested font",
+            Error::FontNotLoaded => "Tried to operate on font that hasn't been loaded",
         }
     }
 }
@@ -129,7 +129,6 @@ impl ::Rasterize for Rasterizer {
     type Err = Error;
 
     fn new(device_pixel_ratio: f32, use_thin_strokes: bool) -> Result<Rasterizer, Error> {
-        info!("device_pixel_ratio: {}", device_pixel_ratio);
         Ok(Rasterizer {
             fonts: HashMap::new(),
             keys: HashMap::new(),
@@ -332,7 +331,7 @@ fn cascade_list_for_languages(
 pub fn descriptors_for_family(family: &str) -> Vec<Descriptor> {
     let mut out = Vec::new();
 
-    info!("family: {}", family);
+    trace!("Family: {}", family);
     let ct_collection = match create_for_family(family) {
         Some(c) => c,
         None => return out,
@@ -627,7 +626,7 @@ mod tests {
     fn get_descriptors_and_build_font() {
         let list = super::descriptors_for_family("Menlo");
         assert!(!list.is_empty());
-        info!("{:?}", list);
+        println!("{:?}", list);
 
         // Check to_font
         let fonts = list.iter()
diff --git a/font/src/ft/fc/font_set.rs b/font/src/ft/fc/font_set.rs
index 6b63f439..4eccd487 100644
--- a/font/src/ft/fc/font_set.rs
+++ b/font/src/ft/fc/font_set.rs
@@ -63,7 +63,7 @@ impl<'a> IntoIterator for &'a FontSet {
             (*self.as_ptr()).nfont as isize
         };
 
-        info!("num fonts = {}", num_fonts);
+        trace!("Number of fonts is {}", num_fonts);
 
         Iter {
             font_set: self.deref(),
@@ -81,7 +81,7 @@ impl<'a> IntoIterator for &'a FontSetRef {
             (*self.as_ptr()).nfont as isize
         };
 
-        info!("num fonts = {}", num_fonts);
+        trace!("Number of fonts is {}", num_fonts);
 
         Iter {
             font_set: self,
diff --git a/font/src/ft/mod.rs b/font/src/ft/mod.rs
index 1d375295..6bcda2a1 100644
--- a/font/src/ft/mod.rs
+++ b/font/src/ft/mod.rs
@@ -117,7 +117,7 @@ impl ::Rasterize for FreeTypeRasterizer {
             },
             _ => {
                 // Fallback if font doesn't provide info about strikeout
-                trace!("No strikeout data available for font, using fallback.");
+                trace!("Using fallback strikeout metrics");
                 let strikeout_position = height as f32 / 2. + descent;
                 (strikeout_position, underline_thickness)
             },
@@ -267,7 +267,7 @@ impl FreeTypeRasterizer {
                 return Ok(Some(*key));
             }
 
-            trace!("got font path={:?}", path);
+            trace!("Got font path={:?}", path);
             let ft_face = self.library.new_face(&path, index)?;
 
             // Get available pixel sizes if font isn't scalable.
@@ -550,12 +550,12 @@ impl FreeTypeRasterizer {
                         // We've previously loaded this font, so don't
                         // load it again.
                         Some(&key) => {
-                            debug!("Hit for font {:?}; no need to load.", path);
+                            debug!("Hit for font {:?}; no need to load", path);
                             Ok(key)
                         },
 
                         None => {
-                            debug!("Miss for font {:?}; loading now.", path);
+                            debug!("Miss for font {:?}; loading now", path);
                             // Safe to unwrap the option since we've already checked for the path
                             // and index above.
                             let key = self.face_from_pattern(&pattern)?.unwrap();
@@ -604,9 +604,9 @@ impl ::std::error::Error for Error {
     fn description(&self) -> &str {
         match *self {
             Error::FreeType(ref err) => err.description(),
-            Error::MissingFont(ref _desc) => "couldn't find the requested font",
-            Error::FontNotLoaded => "tried to operate on font that hasn't been loaded",
-            Error::MissingSizeMetrics => "tried to get size metrics from a face without a size",
+            Error::MissingFont(ref _desc) => "Couldn't find the requested font",
+            Error::FontNotLoaded => "Tried to operate on font that hasn't been loaded",
+            Error::MissingSizeMetrics => "Tried to get size metrics from a face without a size",
         }
     }
 }
diff --git a/font/src/lib.rs b/font/src/lib.rs
index fdba4b87..6fc418dd 100644
--- a/font/src/lib.rs
+++ b/font/src/lib.rs
@@ -132,7 +132,7 @@ impl FontDesc {
 
 impl fmt::Display for FontDesc {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "name '{}' and style '{}'", self.name, self.style)
+        write!(f, "name {} and style {}", self.name, self.style)
     }
 }
 
diff --git a/font/src/rusttype/mod.rs b/font/src/rusttype/mod.rs
index bd4b8df1..add23605 100644
--- a/font/src/rusttype/mod.rs
+++ b/font/src/rusttype/mod.rs
@@ -166,10 +166,10 @@ pub enum Error {
 impl ::std::error::Error for Error {
     fn description(&self) -> &str {
         match *self {
-            Error::MissingFont(ref _desc) => "couldn't find the requested font",
-            Error::UnsupportedFont => "only TrueType fonts are supported",
-            Error::UnsupportedStyle => "the selected style is not supported by rusttype",
-            Error::MissingGlyph => "the selected font did not have the requested glyph",
+            Error::MissingFont(ref _desc) => "Couldn't find the requested font",
+            Error::UnsupportedFont => "Only TrueType fonts are supported",
+            Error::UnsupportedStyle => "The selected style is not supported by rusttype",
+            Error::MissingGlyph => "The selected font does not have the requested glyph",
         }
     }
 }
diff --git a/src/ansi.rs b/src/ansi.rs
index 29b1a459..34a765f7 100644
--- a/src/ansi.rs
+++ b/src/ansi.rs
@@ -445,7 +445,7 @@ impl Mode {
                 1049 => Mode::SwapScreenAndSetRestoreCursor,
                 2004 => Mode::BracketedPaste,
                 _ => {
-                    trace!("[unhandled] mode={:?}", num);
+                    trace!("[unimplemented] primitive mode: {}", num);
                     return None
                 }
             })
diff --git a/src/config.rs b/src/config.rs
index 95989cb0..200acbfe 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -73,7 +73,7 @@ fn deserialize_duration_ms<'a, D>(deserializer: D) -> ::std::result::Result<Dura
     match u64::deserialize(deserializer) {
         Ok(threshold_ms) => Ok(Duration::from_millis(threshold_ms)),
         Err(err) => {
-            error!("problem with config: {}; Using default value", err);
+            error!("Problem with config: {}; using default value", err);
             Ok(default_threshold_ms())
         },
     }
@@ -171,7 +171,7 @@ fn deserialize_visual_bell_duration<'a, D>(deserializer: D) -> ::std::result::Re
     match u16::deserialize(deserializer) {
         Ok(duration) => Ok(duration),
         Err(err) => {
-            error!("problem with config: {}; Using default value", err);
+            error!("Problem with config: {}; using default value", err);
             Ok(0)
         },
     }
@@ -320,19 +320,19 @@ impl<'de> Deserialize<'de> for Decorations {
                     "none" => Ok(Decorations::None),
                     "full" => Ok(Decorations::Full),
                     "true" => {
-                        error!("deprecated decorations boolean value, \
+                        error!("Deprecated decorations boolean value, \
                                    use one of transparent|buttonless|none|full instead; \
-                                   Falling back to \"full\"");
+                                   falling back to \"full\"");
                         Ok(Decorations::Full)
                     },
                     "false" => {
-                        error!("deprecated decorations boolean value, \
+                        error!("Deprecated decorations boolean value, \
                                    use one of transparent|buttonless|none|full instead; \
-                                   Falling back to \"none\"");
+                                   falling back to \"none\"");
                         Ok(Decorations::None)
                     },
                     _ => {
-                        error!("invalid decorations value: {}; Using default value", value);
+                        error!("Invalid decorations value: {}; using default value", value);
                         Ok(Decorations::Full)
                     }
                 }
@@ -346,23 +346,23 @@ impl<'de> Deserialize<'de> for Decorations {
                     "none" => Ok(Decorations::None),
                     "full" => Ok(Decorations::Full),
                     "true" => {
-                        error!("deprecated decorations boolean value, \
+                        error!("Deprecated decorations boolean value, \
                                    use one of none|full instead; \
-                                   Falling back to \"full\"");
+                                   falling back to \"full\"");
                         Ok(Decorations::Full)
                     },
                     "false" => {
-                        error!("deprecated decorations boolean value, \
+                        error!("Deprecated decorations boolean value, \
                                    use one of none|full instead; \
-                                   Falling back to \"none\"");
+                                   falling back to \"none\"");
                         Ok(Decorations::None)
                     },
                     "transparent" | "buttonless" => {
-                        error!("macos-only decorations value: {}; Using default value", value);
+                        error!("macOS-only decorations value: {}; using default value", value);
                         Ok(Decorations::Full)
                     },
                     _ => {
-                        error!("invalid decorations value: {}; Using default value", value);
+                        error!("Invalid decorations value: {}; using default value", value);
                         Ok(Decorations::Full)
                     }
                 }
@@ -406,7 +406,7 @@ fn deserialize_padding<'a, D>(deserializer: D) -> ::std::result::Result<Delta<u8
     match Delta::deserialize(deserializer) {
         Ok(delta) => Ok(delta),
         Err(err) => {
-            error!("problem with config: {}; Using default value", err);
+            error!("Problem with config: {}; using default value", err);
             Ok(default_padding())
         },
     }
@@ -557,7 +557,7 @@ fn failure_default_vec<'a, D, T>(deserializer: D) -> ::std::result::Result<Vec<T
     let vec = match Vec::<serde_yaml::Value>::deserialize(deserializer) {
         Ok(vec) => vec,
         Err(err) => {
-            error!("problem with config: {}; Using empty vector", err);
+            error!("Problem with config: {}; using empty vector", err);
             return Ok(Vec::new());
         },
     };
@@ -568,7 +568,7 @@ fn failure_default_vec<'a, D, T>(deserializer: D) -> ::std::result::Result<Vec<T
         match T::deserialize(value) {
             Ok(binding) => bindings.push(binding),
             Err(err) => {
-                error!("problem with config: {}; Skipping value", err);
+                error!("Problem with config: {}; skipping value", err);
             },
         }
     }
@@ -586,7 +586,7 @@ fn deserialize_tabspaces<'a, D>(deserializer: D) -> ::std::result::Result<usize,
     match usize::deserialize(deserializer) {
         Ok(value) => Ok(value),
         Err(err) => {
-            error!("problem with config: {}; Using `8`", err);
+            error!("Problem with config: {}; using 8", err);
             Ok(default_tabspaces())
         },
     }
@@ -598,7 +598,7 @@ fn default_true_bool<'a, D>(deserializer: D) -> ::std::result::Result<bool, D::E
     match bool::deserialize(deserializer) {
         Ok(value) => Ok(value),
         Err(err) => {
-            error!("problem with config: {}; Using `true`", err);
+            error!("Problem with config: {}; using true", err);
             Ok(true)
         },
     }
@@ -612,7 +612,7 @@ fn failure_default<'a, D, T>(deserializer: D)
     match T::deserialize(deserializer) {
         Ok(value) => Ok(value),
         Err(err) => {
-            error!("problem with config: {}; Using default value", err);
+            error!("Problem with config: {}; using default value", err);
             Ok(T::default())
         },
     }
@@ -675,8 +675,8 @@ fn deserialize_scrolling_history<'a, D>(deserializer: D) -> ::std::result::Resul
         Ok(lines) => {
             if lines > MAX_SCROLLBACK_LINES {
                 error!(
-                    "problem with config: scrollback size is {}, but expected a maximum of {}; \
-                     Using {1} instead",
+                    "Problem with config: scrollback size is {}, but expected a maximum of {}; \
+                     using {1} instead",
                     lines, MAX_SCROLLBACK_LINES,
                 );
                 Ok(MAX_SCROLLBACK_LINES)
@@ -685,7 +685,7 @@ fn deserialize_scrolling_history<'a, D>(deserializer: D) -> ::std::result::Resul
             }
         },
         Err(err) => {
-            error!("problem with config: {}; Using default value", err);
+            error!("Problem with config: {}; using default value", err);
             Ok(default_scrolling_history())
         },
     }
@@ -697,7 +697,7 @@ fn deserialize_scrolling_multiplier<'a, D>(deserializer: D) -> ::std::result::Re
     match u8::deserialize(deserializer) {
         Ok(lines) => Ok(lines),
         Err(err) => {
-            error!("problem with config: {}; Using default value", err);
+            error!("Problem with config: {}; using default value", err);
             Ok(default_scrolling_multiplier())
         },
     }
@@ -739,7 +739,7 @@ impl<'a> de::Deserialize<'a> for ModsWrapper {
                         "Shift" => res.shift = true,
                         "Alt" | "Option" => res.alt = true,
                         "Control" => res.ctrl = true,
-                        _ => error!("unknown modifier {:?}", modifier),
+                        _ => error!("Unknown modifier {:?}", modifier),
                     }
                 }
 
@@ -862,7 +862,7 @@ impl<'a> de::Deserialize<'a> for ModeWrapper {
                         "~AppCursor" => res.not_mode |= mode::TermMode::APP_CURSOR,
                         "AppKeypad" => res.mode |= mode::TermMode::APP_KEYPAD,
                         "~AppKeypad" => res.not_mode |= mode::TermMode::APP_KEYPAD,
-                        _ => error!("unknown mode {:?}", modifier),
+                        _ => error!("Unknown mode {:?}", modifier),
                     }
                 }
 
@@ -1045,7 +1045,7 @@ impl<'a> de::Deserialize<'a> for RawBinding {
                                 let scancode = val.as_u64().unwrap();
                                 if scancode > u64::from(::std::u32::MAX) {
                                     return Err(<V::Error as Error>::custom(format!(
-                                        "invalid key binding, scancode too big: {}",
+                                        "Invalid key binding, scancode too big: {}",
                                         scancode
                                     )));
                                 }
@@ -1225,9 +1225,9 @@ fn deserialize_color_index<'a, D>(deserializer: D) -> ::std::result::Result<u8,
         Ok(index) => {
             if index < 16 {
                 error!(
-                    "problem with config: indexed_color's index is '{}', \
+                    "Problem with config: indexed_color's index is {}, \
                      but a value bigger than 15 was expected; \
-                     Ignoring setting",
+                     ignoring setting",
                     index
                 );
 
@@ -1238,7 +1238,7 @@ fn deserialize_color_index<'a, D>(deserializer: D) -> ::std::result::Result<u8,
             }
         },
         Err(err) => {
-            error!("problem with config: {}; Ignoring setting", err);
+            error!("Problem with config: {}; ignoring setting", err);
 
             // Return value out of range to ignore this color
             Ok(0)
@@ -1293,7 +1293,7 @@ fn deserialize_optional_color<'a, D>(deserializer: D) -> ::std::result::Result<O
         },
         Ok(None) => Ok(None),
         Err(err) => {
-            error!("problem with config: {}; Using standard foreground color", err);
+            error!("Problem with config: {}; using standard foreground color", err);
             Ok(None)
         },
     }
@@ -1375,14 +1375,14 @@ fn rgb_from_hex<'a, D>(deserializer: D) -> ::std::result::Result<Rgb, D::Error>
         type Value = Rgb;
 
         fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.write_str("Hex colors spec like 'ffaabb'")
+            f.write_str("hex color like 0xff00ff")
         }
 
         fn visit_str<E>(self, value: &str) -> ::std::result::Result<Rgb, E>
             where E: ::serde::de::Error
         {
             Rgb::from_str(&value[..])
-                .map_err(|_| E::custom("failed to parse rgb; expect 0xrrggbb"))
+                .map_err(|_| E::custom("failed to parse rgb; expected hex color like 0xff00ff"))
         }
     }
 
@@ -1392,7 +1392,7 @@ fn rgb_from_hex<'a, D>(deserializer: D) -> ::std::result::Result<Rgb, D::Error>
     match rgb {
         Ok(rgb) => Ok(rgb),
         Err(err) => {
-            error!("problem with config: {}; Using color #ff00ff", err);
+            error!("Problem with config: {}; using color #ff00ff", err);
             Ok(Rgb { r: 255, g: 0, b: 255 })
         },
     }
@@ -1444,8 +1444,8 @@ impl ::std::error::Error for Error {
 
     fn description(&self) -> &str {
         match *self {
-            Error::NotFound => "could not locate config file",
-            Error::Empty => "empty config file",
+            Error::NotFound => "Couldn't locate config file",
+            Error::Empty => "Empty config file",
             Error::ReadingEnvHome(ref err) => err.description(),
             Error::Io(ref err) => err.description(),
             Error::Yaml(ref err) => err.description(),
@@ -1458,10 +1458,10 @@ impl ::std::fmt::Display for Error {
         match *self {
             Error::NotFound | Error::Empty => write!(f, "{}", ::std::error::Error::description(self)),
             Error::ReadingEnvHome(ref err) => {
-                write!(f, "could not read $HOME environment variable: {}", err)
+                write!(f, "Couldn't read $HOME environment variable: {}", err)
             },
-            Error::Io(ref err) => write!(f, "error reading config file: {}", err),
-            Error::Yaml(ref err) => write!(f, "problem with config: {}", err),
+            Error::Io(ref err) => write!(f, "Error reading config file: {}", err),
+            Error::Yaml(ref err) => write!(f, "Problem with config: {}", err),
         }
     }
 }
@@ -1538,7 +1538,7 @@ impl Config {
 
         if let Some(old_path) = old.as_ref().filter(|old| old.exists()) {
             warn!(
-                "Found configuration at: '{}'. The file should be moved to the new location: '{}'.",
+                "Found configuration at: {}; this file should be moved to the new location: {}",
                 old_path.to_string_lossy(),
                 new.as_ref().map(|new| new.to_string_lossy()).unwrap(),
             );
@@ -1564,7 +1564,7 @@ impl Config {
     pub fn write_defaults() -> io::Result<Cow<'static, Path>> {
         let mut path = dirs::config_dir()
             .ok_or_else(|| {
-                io::Error::new(io::ErrorKind::NotFound, "could not find profile directory")
+                io::Error::new(io::ErrorKind::NotFound, "Couldn't find profile directory")
             }
         )?;
 
@@ -1765,21 +1765,22 @@ impl Config {
 
     fn print_deprecation_warnings(&mut self) {
         if self.dimensions.is_some() {
-            warn!("{}", "Config `dimensions` is deprecated. \
-                  Please use `window.dimensions` instead.");
+            warn!("Config dimensions is deprecated; \
+                  please use window.dimensions instead");
         }
 
         if self.padding.is_some() {
-            warn!("{}", "Config `padding` is deprecated. Please use `window.padding` instead.");
+            warn!("Config padding is deprecated; \
+                  please use window.padding instead");
         }
 
         if self.mouse.faux_scrollback_lines.is_some() {
-            warn!("{}", "Config `mouse.faux_scrollback_lines` is deprecated. \
-                  Please use `mouse.faux_scrolling_lines` instead.");
+            warn!("Config mouse.faux_scrollback_lines is deprecated; \
+                  please use mouse.faux_scrolling_lines instead");
         }
 
         if let Some(custom_cursor_colors) = self.custom_cursor_colors {
-            warn!("{}", "Config `custom_cursor_colors` is deprecated.");
+            warn!("Config custom_cursor_colors is deprecated");
 
             if !custom_cursor_colors {
                 self.colors.cursor.cursor = None;
@@ -1788,17 +1789,18 @@ impl Config {
         }
 
         if self.cursor_style.is_some() {
-            warn!("{}", "Config `cursor_style` is deprecated. Please use `cursor.style` instead.");
+            warn!("Config cursor_style is deprecated; \
+                  please use cursor.style instead");
         }
 
         if self.hide_cursor_when_typing.is_some() {
-            warn!("{}", "Config `hide_cursor_when_typing` is deprecated. \
-                  Please use `mouse.hide_when_typing` instead.");
+            warn!("Config hide_cursor_when_typing is deprecated; \
+                  please use mouse.hide_when_typing instead");
         }
 
         if self.unfocused_hollow_cursor.is_some() {
-            warn!("{}", "Config `unfocused_hollow_cursor` is deprecated. \
-                  Please use `cursor.unfocused_hollow` instead.");
+            warn!("Config unfocused_hollow_cursor is deprecated; \
+                  please use cursor.unfocused_hollow instead");
         }
     }
 }
@@ -1899,7 +1901,7 @@ impl DeserializeSize for Size {
         match size {
             Ok(size) => Ok(size),
             Err(err) => {
-                error!("problem with config: {}; Using size 12", err);
+                error!("Problem with config: {}; using size 12", err);
                 Ok(Size::new(12.))
             },
         }
@@ -1949,7 +1951,7 @@ where
 {
     // This is necessary in order to get serde to complete deserialization of the configuration
     let _ignored = bool::deserialize(deserializer);
-    error!("The `scale_with_dpi` setting has been removed, \
+    error!("The scale_with_dpi setting has been removed, \
             on X11 the WINIT_HIDPI_FACTOR environment variable can be used instead.");
     Ok(None)
 }
diff --git a/src/display.rs b/src/display.rs
index b1575c58..d5a8978b 100644
--- a/src/display.rs
+++ b/src/display.rs
@@ -144,7 +144,7 @@ impl Display {
         let mut window = Window::new(&options, config.window())?;
 
         let dpr = window.hidpi_factor();
-        info!("device_pixel_ratio: {}", dpr);
+        info!("Device pixel ratio: {}", dpr);
 
         // get window properties for initializing the other subsystems
         let mut viewport_size = window.inner_size_pixels()
@@ -241,15 +241,16 @@ impl Display {
 
         // Initialize glyph cache
         let glyph_cache = {
-            info!("Initializing glyph cache");
+            info!("Initializing glyph cache...");
             let init_start = ::std::time::Instant::now();
 
             let cache =
                 renderer.with_loader(|mut api| GlyphCache::new(rasterizer, &font, &mut api))?;
 
             let stop = init_start.elapsed();
-            let stop_f = stop.as_secs() as f64 + f64::from(stop.subsec_nanos()) / 1_000_000_000f64;
-            info!("Finished initializing glyph cache in {}", stop_f);
+            let stop_f = stop.as_secs() as f64 +
+                         f64::from(stop.subsec_nanos()) / 1_000_000_000f64;
+            info!("... finished initializing glyph cache in {}s", stop_f);
 
             cache
         };
diff --git a/src/event_loop.rs b/src/event_loop.rs
index 20ce3ae6..748e2bde 100644
--- a/src/event_loop.rs
+++ b/src/event_loop.rs
@@ -385,10 +385,10 @@ impl<T> EventLoop<T>
                                 if let Err(err) = self.pty_read(&mut state, &mut buf, pipe.as_mut())
                                     {
                                         error!(
-                                            "Event loop exitting due to error: {} [{}:{}]",
-                                            err,
+                                            "[{}:{}] Event loop exiting due to error: {}",
                                             file!(),
-                                            line!()
+                                            line!(),
+                                            err
                                         );
                                         break 'event_loop;
                                     }
@@ -401,10 +401,10 @@ impl<T> EventLoop<T>
                             if event.readiness().is_writable() {
                                 if let Err(err) = self.pty_write(&mut state) {
                                     error!(
-                                        "Event loop exitting due to error: {} [{}:{}]",
-                                        err,
+                                        "[{}:{}] Event loop exiting due to error: {}",
                                         file!(),
-                                        line!()
+                                        line!(),
+                                        err
                                     );
                                     break 'event_loop;
                                 }
diff --git a/src/grid/tests.rs b/src/grid/tests.rs
index 2e06c10e..560bb0fe 100644
--- a/src/grid/tests.rs
+++ b/src/grid/tests.rs
@@ -84,8 +84,6 @@ fn scroll_down() {
 // Test that GridIterator works
 #[test]
 fn test_iter() {
-    info!("");
-
     let mut grid = Grid::new(Line(5), Column(5), 0, 0);
     for i in 0..5 {
         for j in 0..5 {
@@ -93,8 +91,6 @@ fn test_iter() {
         }
     }
 
-    info!("grid: {:?}", grid);
-
     let mut iter = grid.iter_from(Point {
         line: 4,
         col: Column(0),
diff --git a/src/input.rs b/src/input.rs
index 8b3bcbed..45956794 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -224,7 +224,7 @@ impl Action {
                     .and_then(|clipboard| clipboard.load_primary() )
                     .map(|contents| { self.paste(ctx, &contents) })
                     .unwrap_or_else(|err| {
-                        error!("Error loading data from clipboard. {}", Red(err));
+                        error!("Error loading data from clipboard: {}", Red(err));
                     });
             },
             Action::PasteSelection => {
@@ -234,19 +234,19 @@ impl Action {
                         .and_then(|clipboard| clipboard.load_selection() )
                         .map(|contents| { self.paste(ctx, &contents) })
                         .unwrap_or_else(|err| {
-                            error!("Error loading data from clipboard. {}", Red(err));
+                            error!("Error loading data from clipboard: {}", Red(err));
                         });
                 }
             },
             Action::Command(ref program, ref args) => {
-                trace!("running command: {} {:?}", program, args);
+                trace!("Running command {} with args {:?}", program, args);
 
                 match start_daemon(program, args) {
                     Ok(_) => {
-                        debug!("spawned new proc");
+                        debug!("Spawned new proc");
                     },
                     Err(err) => {
-                        warn!("couldn't run command: {}", err);
+                        warn!("Couldn't run command {}", err);
                     },
                 }
             },
@@ -546,8 +546,8 @@ impl<'a, A: ActionContext + 'a> Processor<'a, A> {
         args.push(text);
 
         match start_daemon(launcher.program(), &args) {
-            Ok(_) => debug!("Launched: {} {:?}", launcher.program(), args),
-            Err(_) => warn!("Unable to launch: {} {:?}", launcher.program(), args),
+            Ok(_) => debug!("Launched {} with args {:?}", launcher.program(), args),
+            Err(_) => warn!("Unable to launch {} with args {:?}", launcher.program(), args),
         }
 
         Some(())
diff --git a/src/logging.rs b/src/logging.rs
index 1767724c..893a39a2 100644
--- a/src/logging.rs
+++ b/src/logging.rs
@@ -125,13 +125,26 @@ impl log::Log for Logger {
     }
 
     fn log(&self, record: &log::Record<'_>) {
-        if self.enabled(record.metadata()) && record.target().starts_with("alacritty") {
-            let msg = format!(
-                "[{}] [{}] {}\n",
-                time::now().strftime("%F %R").unwrap(),
-                record.level(),
-                record.args()
-            );
+        if self.enabled(record.metadata()) &&
+           record.target().starts_with("alacritty")
+        {
+            let now = time::strftime("%F %R", &time::now()).unwrap();
+
+            let msg = if record.level() >= Level::Trace {
+                format!("[{}] [{}] [{}:{}] {}\n",
+                        now,
+                        record.level(),
+                        record.file().unwrap_or("?"),
+                        record.line()
+                              .map(|l| l.to_string())
+                              .unwrap_or("?".to_string()),
+                        record.args())
+            } else {
+                format!("[{}] [{}] {}\n",
+                        now,
+                        record.level(),
+                        record.args())
+            };
 
             if let Ok(ref mut logfile) = self.logfile.lock() {
                 let _ = logfile.write_all(msg.as_ref());
diff --git a/src/main.rs b/src/main.rs
index ca8da5af..7c23616d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -99,8 +99,8 @@ fn load_config(options: &cli::Options) -> Config {
 
     Config::load_from(&*config_path).unwrap_or_else(|err| {
         match err {
-            ConfigError::Empty => info!("Config file {:?} is empty; Loading default", config_path),
-            _ => error!("Error: {}; Loading default config", err),
+            ConfigError::Empty => info!("Config file {:?} is empty; loading default", config_path),
+            _ => error!("Error: {}; loading default config", err),
         }
 
         Config::default()
@@ -116,9 +116,9 @@ fn run(
     options: &cli::Options,
     mut logger_proxy: LoggerProxy,
 ) -> Result<(), Box<dyn Error>> {
-    info!("Welcome to Alacritty.");
+    info!("Welcome to Alacritty");
     if let Some(config_path) = config.path() {
-        info!("Configuration loaded from {}", config_path.display());
+        info!("Configuration loaded from {:?}", config_path.display());
     };
 
     // Set environment variables
@@ -264,7 +264,7 @@ fn run(
     #[cfg(windows)]
     unsafe { FreeConsole(); }
 
-    info!("Goodbye.");
+    info!("Goodbye");
 
     if !options.persistent_logging && !config.persistent_logging() {
         logger_proxy.delete_log();
diff --git a/src/renderer/mod.rs b/src/renderer/mod.rs
index 42a17486..4d5d8de3 100644
--- a/src/renderer/mod.rs
+++ b/src/renderer/mod.rs
@@ -321,7 +321,7 @@ impl GlyphCache {
         self.rasterizer.get_glyph(GlyphKey { font_key: regular, c: 'm', size: font.size() })?;
         let metrics = self.rasterizer.metrics(regular, size)?;
 
-        info!("Font size changed: {:?} [DPR: {}]", font.size, dpr);
+        info!("Font size changed to {:?} with DPR of {}", font.size, dpr);
 
         self.font_size = font.size;
         self.font_key = regular;
@@ -816,26 +816,15 @@ impl QuadRenderer {
     }
 
     pub fn reload_shaders(&mut self, size: PhysicalSize) {
-        warn!("Reloading shaders ...");
+        warn!("Reloading shaders...");
         let result = (TextShaderProgram::new(size), RectShaderProgram::new());
         let (program, rect_program) = match result {
             (Ok(program), Ok(rect_program)) => {
-                warn!(" ... OK");
+                info!("... successfully reloaded shaders");
                 (program, rect_program)
             }
             (Err(err), _) | (_, Err(err)) => {
-                match err {
-                    ShaderCreationError::Io(err) => {
-                        error!("Error reading shader file: {}", err);
-                    }
-                    ShaderCreationError::Compile(path, log) => {
-                        error!("Error compiling shader at {:?}\n{}", path, log);
-                    }
-                    ShaderCreationError::Link(log) => {
-                        error!("Error reloading shaders: {}", log);
-                    }
-                }
-
+                error!("{}", err);
                 return;
             }
         };
@@ -1234,7 +1223,7 @@ impl TextShaderProgram {
         );
         let projection: [[f32; 4]; 4] = ortho.into();
 
-        info!("width: {}, height: {}", width, height);
+        info!("Width: {}, Height: {}", width, height);
 
         unsafe {
             gl::UniformMatrix4fv(
@@ -1483,11 +1472,15 @@ impl ::std::error::Error for ShaderCreationError {
 impl ::std::fmt::Display for ShaderCreationError {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            ShaderCreationError::Io(ref err) => write!(f, "couldn't read shader: {}", err),
-            ShaderCreationError::Compile(ref _path, ref s) => {
-                write!(f, "failed compiling shader: {}", s)
-            }
-            ShaderCreationError::Link(ref s) => write!(f, "failed linking shader: {}", s),
+            ShaderCreationError::Io(ref err) => {
+                write!(f, "Couldn't read shader: {}", err)
+            },
+            ShaderCreationError::Compile(ref path, ref log) => {
+                write!(f, "Failed compiling shader at {}: {}", path.display(), log)
+            },
+            ShaderCreationError::Link(ref log) => {
+                write!(f, "Failed linking shader: {}", log)
+            },
         }
     }
 }
diff --git a/src/term/mod.rs b/src/term/mod.rs
index dadfaf78..a35a5df0 100644
--- a/src/term/mod.rs
+++ b/src/term/mod.rs
@@ -1167,7 +1167,7 @@ impl Term {
 
     /// Resize terminal to new dimensions
     pub fn resize(&mut self, size : &SizeInfo) {
-        debug!("Term::resize");
+        debug!("Resizing terminal");
 
         // Bounds check; lots of math assumes width and height are > 0
         if size.width as usize <= 2 * self.size_info.padding_x as usize ||
@@ -1224,7 +1224,7 @@ impl Term {
             }
         }
 
-        debug!("num_cols, num_lines = {}, {}", num_cols, num_lines);
+        debug!("New num_cols is {} and num_lines is {}", num_cols, num_lines);
 
         // Resize grids to new size
         self.grid.resize(num_lines, num_cols, &Cell::default());
@@ -1276,7 +1276,7 @@ impl Term {
     /// Expects origin to be in scroll range.
     #[inline]
     fn scroll_down_relative(&mut self, origin: Line, mut lines: Line) {
-        trace!("scroll_down_relative: origin={}, lines={}", origin, lines);
+        trace!("Scrolling down relative: origin={}, lines={}", origin, lines);
         lines = min(lines, self.scroll_region.end - self.scroll_region.start);
         lines = min(lines, self.scroll_region.end - origin);
 
@@ -1290,7 +1290,7 @@ impl Term {
     /// Expects origin to be in scroll range.
     #[inline]
     fn scroll_up_relative(&mut self, origin: Line, lines: Line) {
-        trace!("scroll_up_relative: origin={}, lines={}", origin, lines);
+        trace!("Scrolling up relative: origin={}, lines={}", origin, lines);
         let lines = min(lines, self.scroll_region.end - self.scroll_region.start);
 
         // Scroll from origin to bottom less number of lines
@@ -1354,7 +1354,7 @@ impl ansi::Handler for Term {
                 return;
             }
 
-            trace!("wrapping");
+            trace!("Wrapping input");
 
             {
                 let location = Point {
@@ -1434,7 +1434,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn dectest(&mut self) {
-        trace!("dectest");
+        trace!("Dectesting");
         let mut template = self.cursor.template;
         template.c = 'E';
 
@@ -1444,7 +1444,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn goto(&mut self, line: Line, col: Column) {
-        trace!("goto: line={}, col={}", line, col);
+        trace!("Going to: line={}, col={}", line, col);
         let (y_offset, max_y) = if self.mode.contains(mode::TermMode::ORIGIN) {
             (self.scroll_region.start, self.scroll_region.end - 1)
         } else {
@@ -1458,13 +1458,13 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn goto_line(&mut self, line: Line) {
-        trace!("goto_line: {}", line);
+        trace!("Going to line: {}", line);
         self.goto(line, self.cursor.point.col)
     }
 
     #[inline]
     fn goto_col(&mut self, col: Column) {
-        trace!("goto_col: {}", col);
+        trace!("Going to column: {}", col);
         self.goto(self.cursor.point.line, col)
     }
 
@@ -1497,28 +1497,28 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn move_up(&mut self, lines: Line) {
-        trace!("move_up: {}", lines);
+        trace!("Moving up: {}", lines);
         let move_to = Line(self.cursor.point.line.0.saturating_sub(lines.0));
         self.goto(move_to, self.cursor.point.col)
     }
 
     #[inline]
     fn move_down(&mut self, lines: Line) {
-        trace!("move_down: {}", lines);
+        trace!("Moving down: {}", lines);
         let move_to = self.cursor.point.line + lines;
         self.goto(move_to, self.cursor.point.col)
     }
 
     #[inline]
     fn move_forward(&mut self, cols: Column) {
-        trace!("move_forward: {}", cols);
+        trace!("Moving forward: {}", cols);
         self.cursor.point.col = min(self.cursor.point.col + cols, self.grid.num_cols() - 1);
         self.input_needs_wrap = false;
     }
 
     #[inline]
     fn move_backward(&mut self, cols: Column) {
-        trace!("move_backward: {}", cols);
+        trace!("Moving backward: {}", cols);
         self.cursor.point.col -= min(self.cursor.point.col, cols);
         self.input_needs_wrap = false;
     }
@@ -1530,7 +1530,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn device_status<W: io::Write>(&mut self, writer: &mut W, arg: usize) {
-        trace!("device status: {}", arg);
+        trace!("Reporting device status: {}", arg);
         match arg {
             5 => {
                 let _ = writer.write_all(b"\x1b[0n");
@@ -1545,21 +1545,21 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn move_down_and_cr(&mut self, lines: Line) {
-        trace!("move_down_and_cr: {}", lines);
+        trace!("Moving down and cr: {}", lines);
         let move_to = self.cursor.point.line + lines;
         self.goto(move_to, Column(0))
     }
 
     #[inline]
     fn move_up_and_cr(&mut self, lines: Line) {
-        trace!("move_up_and_cr: {}", lines);
+        trace!("Moving up and cr: {}", lines);
         let move_to = Line(self.cursor.point.line.0.saturating_sub(lines.0));
         self.goto(move_to, Column(0))
     }
 
     #[inline]
     fn put_tab(&mut self, mut count: i64) {
-        trace!("put_tab: {}", count);
+        trace!("Putting tab: {}", count);
 
         while self.cursor.point.col < self.grid.num_cols() && count != 0 {
             count -= 1;
@@ -1587,7 +1587,7 @@ impl ansi::Handler for Term {
     /// Backspace `count` characters
     #[inline]
     fn backspace(&mut self) {
-        trace!("backspace");
+        trace!("Backspace");
         if self.cursor.point.col > Column(0) {
             self.cursor.point.col -= 1;
             self.input_needs_wrap = false;
@@ -1597,7 +1597,7 @@ impl ansi::Handler for Term {
     /// Carriage return
     #[inline]
     fn carriage_return(&mut self) {
-        trace!("carriage_return");
+        trace!("Carriage return");
         self.cursor.point.col = Column(0);
         self.input_needs_wrap = false;
     }
@@ -1605,7 +1605,7 @@ impl ansi::Handler for Term {
     /// Linefeed
     #[inline]
     fn linefeed(&mut self) {
-        trace!("linefeed");
+        trace!("Linefeed");
         let next = self.cursor.point.line + 1;
         if next == self.scroll_region.end {
             self.scroll_up(Line(1));
@@ -1617,14 +1617,14 @@ impl ansi::Handler for Term {
     /// Set current position as a tabstop
     #[inline]
     fn bell(&mut self) {
-        trace!("bell");
+        trace!("Bell");
         self.visual_bell.ring();
         self.next_is_urgent = Some(true);
     }
 
     #[inline]
     fn substitute(&mut self) {
-        trace!("[unimplemented] substitute");
+        trace!("[unimplemented] Substitute");
     }
 
     /// Run LF/NL
@@ -1660,7 +1660,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn set_horizontal_tabstop(&mut self) {
-        trace!("set_horizontal_tabstop");
+        trace!("Setting horizontal tabstop");
         let column = self.cursor.point.col;
         self.tabs[column] = true;
     }
@@ -1679,7 +1679,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn insert_blank_lines(&mut self, lines: Line) {
-        trace!("insert_blank_lines: {}", lines);
+        trace!("Inserting blank {} lines", lines);
         if self.scroll_region.contains_(self.cursor.point.line) {
             let origin = self.cursor.point.line;
             self.scroll_down_relative(origin, lines);
@@ -1688,7 +1688,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn delete_lines(&mut self, lines: Line) {
-        trace!("delete_lines: {}", lines);
+        trace!("Deleting {} lines", lines);
         if self.scroll_region.contains_(self.cursor.point.line) {
             let origin = self.cursor.point.line;
             self.scroll_up_relative(origin, lines);
@@ -1697,7 +1697,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn erase_chars(&mut self, count: Column) {
-        trace!("erase_chars: {}, {}", count, self.cursor.point.col);
+        trace!("Erasing chars: count={}, col={}", count, self.cursor.point.col);
         let start = self.cursor.point.col;
         let end = min(start + count, self.grid.num_cols() - 1);
 
@@ -1737,7 +1737,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn move_backward_tabs(&mut self, count: i64) {
-        trace!("move_backward_tabs: {}", count);
+        trace!("Moving backward {} tabs", count);
 
         for _ in 0..count {
             let mut col = self.cursor.point.col;
@@ -1753,12 +1753,12 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn move_forward_tabs(&mut self, count: i64) {
-        trace!("[unimplemented] move_forward_tabs: {}", count);
+        trace!("[unimplemented] Moving forward {} tabs", count);
     }
 
     #[inline]
     fn save_cursor_position(&mut self) {
-        trace!("CursorSave");
+        trace!("Saving cursor position");
         let cursor = if self.alt {
             &mut self.cursor_save_alt
         } else {
@@ -1770,7 +1770,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn restore_cursor_position(&mut self) {
-        trace!("CursorRestore");
+        trace!("Restoring cursor position");
         let source = if self.alt {
             &self.cursor_save_alt
         } else {
@@ -1784,7 +1784,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn clear_line(&mut self, mode: ansi::LineClearMode) {
-        trace!("clear_line: {:?}", mode);
+        trace!("Clearing line: {:?}", mode);
         let mut template = self.cursor.template;
         template.flags ^= template.flags;
 
@@ -1815,7 +1815,7 @@ impl ansi::Handler for Term {
     /// Set the indexed color value
     #[inline]
     fn set_color(&mut self, index: usize, color: Rgb) {
-        trace!("set_color[{}] = {:?}", index, color);
+        trace!("Setting color[{}] = {:?}", index, color);
         self.colors[index] = color;
         self.color_modified[index] = true;
     }
@@ -1823,7 +1823,7 @@ impl ansi::Handler for Term {
     /// Reset the indexed color to original value
     #[inline]
     fn reset_color(&mut self, index: usize) {
-        trace!("reset_color[{}]", index);
+        trace!("Reseting color[{}]", index);
         self.colors[index] = self.original_colors[index];
         self.color_modified[index] = false;
     }
@@ -1835,13 +1835,13 @@ impl ansi::Handler for Term {
         Clipboard::new()
             .and_then(|mut clipboard| clipboard.store_primary(string))
             .unwrap_or_else(|err| {
-                warn!("Error storing selection to clipboard. {}", err);
+                warn!("Error storing selection to clipboard: {}", err);
             });
     }
 
     #[inline]
     fn clear_screen(&mut self, mode: ansi::ClearMode) {
-        trace!("clear_screen: {:?}", mode);
+        trace!("Clearing screen: {:?}", mode);
         let mut template = self.cursor.template;
         template.flags ^= template.flags;
 
@@ -1881,7 +1881,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn clear_tabs(&mut self, mode: ansi::TabulationClearMode) {
-        trace!("clear_tabs: {:?}", mode);
+        trace!("Clearing tabs: {:?}", mode);
         match mode {
             ansi::TabulationClearMode::Current => {
                 let column = self.cursor.point.col;
@@ -1916,7 +1916,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn reverse_index(&mut self) {
-        trace!("reverse_index");
+        trace!("Reversing index");
         // if cursor is at the top
         if self.cursor.point.line == self.scroll_region.start {
             self.scroll_down(Line(1));
@@ -1928,7 +1928,7 @@ impl ansi::Handler for Term {
     /// set a terminal attribute
     #[inline]
     fn terminal_attribute(&mut self, attr: Attr) {
-        trace!("Set Attribute: {:?}", attr);
+        trace!("Setting attribute: {:?}", attr);
         match attr {
             Attr::Foreground(color) => self.cursor.template.fg = color,
             Attr::Background(color) => self.cursor.template.bg = color,
@@ -1959,7 +1959,7 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn set_mode(&mut self, mode: ansi::Mode) {
-        trace!("set_mode: {:?}", mode);
+        trace!("Setting mode: {:?}", mode);
         match mode {
             ansi::Mode::SwapScreenAndSetRestoreCursor => {
                 self.mode.insert(mode::TermMode::ALT_SCREEN);
@@ -1991,15 +1991,15 @@ impl ansi::Handler for Term {
             ansi::Mode::Origin => self.mode.insert(mode::TermMode::ORIGIN),
             ansi::Mode::DECCOLM => self.deccolm(),
             ansi::Mode::Insert => self.mode.insert(mode::TermMode::INSERT), // heh
-            _ => {
-                trace!(".. ignoring set_mode");
+            ansi::Mode::BlinkingCursor => {
+                trace!("... unimplemented mode");
             }
         }
     }
 
     #[inline]
     fn unset_mode(&mut self,mode: ansi::Mode) {
-        trace!("unset_mode: {:?}", mode);
+        trace!("Unsetting mode: {:?}", mode);
         match mode {
             ansi::Mode::SwapScreenAndSetRestoreCursor => {
                 self.mode.remove(mode::TermMode::ALT_SCREEN);
@@ -2031,15 +2031,15 @@ impl ansi::Handler for Term {
             ansi::Mode::Origin => self.mode.remove(mode::TermMode::ORIGIN),
             ansi::Mode::DECCOLM => self.deccolm(),
             ansi::Mode::Insert => self.mode.remove(mode::TermMode::INSERT),
-            _ => {
-                trace!(".. ignoring unset_mode");
+            ansi::Mode::BlinkingCursor => {
+                trace!("... unimplemented mode");
             }
         }
     }
 
     #[inline]
     fn set_scrolling_region(&mut self, region: Range<Line>) {
-        trace!("set scroll region: {:?}", region);
+        trace!("Setting scrolling region: {:?}", region);
         self.scroll_region.start = min(region.start, self.grid.num_lines());
         self.scroll_region.end = min(region.end, self.grid.num_lines());
         self.goto(Line(0), Column(0));
@@ -2047,31 +2047,31 @@ impl ansi::Handler for Term {
 
     #[inline]
     fn set_keypad_application_mode(&mut self) {
-        trace!("set mode::TermMode::APP_KEYPAD");
+        trace!("Setting keypad application mode");
         self.mode.insert(mode::TermMode::APP_KEYPAD);
     }
 
     #[inline]
     fn unset_keypad_application_mode(&mut self) {
-        trace!("unset mode::TermMode::APP_KEYPAD");
+        trace!("Unsetting keypad application mode");
         self.mode.remove(mode::TermMode::APP_KEYPAD);
     }
 
     #[inline]
     fn configure_charset(&mut self, index: CharsetIndex, charset: StandardCharset) {
-        trace!("designate {:?} character set as {:?}", index, charset);
+        trace!("Configuring charset {:?} as {:?}", index, charset);
         self.cursor.charsets[index] = charset;
     }
 
     #[inline]
     fn set_active_charset(&mut self, index: CharsetIndex) {
-        trace!("Activate {:?} character set", index);
+        trace!("Setting active charset {:?}", index);
         self.active_charset = index;
     }
 
     #[inline]
     fn set_cursor_style(&mut self, style: Option<CursorStyle>) {
-        trace!("set_cursor_style {:?}", style);
+        trace!("Setting cursor style {:?}", style);
         self.cursor_style = style;
     }
 }
diff --git a/src/tty/unix.rs b/src/tty/unix.rs
index e8a28c91..2a07fc58 100644
--- a/src/tty/unix.rs
+++ b/src/tty/unix.rs
@@ -316,7 +316,7 @@ pub fn new<T: ToWinsize>(
             pty
         },
         Err(err) => {
-            die!("Command::spawn() failed: {}", err);
+            die!("Failed to spawn command: {}", err);
         }
     }
 }
diff --git a/src/tty/windows/mod.rs b/src/tty/windows/mod.rs
index 1eb442ad..fff40cb3 100644
--- a/src/tty/windows/mod.rs
+++ b/src/tty/windows/mod.rs
@@ -85,10 +85,10 @@ pub fn new<'a>(
     window_id: Option<usize>,
 ) -> Pty<'a> {
     if let Some(pty) = conpty::new(config, options, size, window_id) {
-        info!("Using Conpty agent.");
+        info!("Using Conpty agent");
         pty
     } else {
-        info!("Using Winpty agent.");
+        info!("Using Winpty agent");
         winpty::new(config, options, size, window_id)
     }
 }
diff --git a/winpty/src/windows.rs b/winpty/src/windows.rs
index 10a3df37..03a91a76 100644
--- a/winpty/src/windows.rs
+++ b/winpty/src/windows.rs
@@ -140,8 +140,8 @@ impl<'a> Drop for Config<'a> {
 pub struct Winpty<'a>(&'a mut winpty_t);
 
 impl<'a, 'b> Winpty<'a> {
-    /// Starts the agent. This process will connect to the agent 
-    /// over a control pipe, and the agent will open data pipes 
+    /// Starts the agent. This process will connect to the agent
+    /// over a control pipe, and the agent will open data pipes
     /// (e.g. CONIN and CONOUT).
     pub fn open(cfg: &Config) -> Result<Self, Err<'b>> {
         let mut err = null_mut() as *mut winpty_error_t;
@@ -199,7 +199,7 @@ impl<'a, 'b> Winpty<'a> {
     }
 
     /// Change the size of the Windows console window.
-    /// 
+    ///
     /// cols & rows MUST be greater than 0
     pub fn set_size(&mut self, cols: u16, rows: u16) -> Result<(), Err> {
         assert!(cols > 0 && rows > 0);
@@ -339,7 +339,7 @@ impl<'a> Drop for SpawnConfig<'a> {
         }
     }
 }
- 
+
 #[cfg(test)]
 mod tests {
     extern crate named_pipe;