diff --git a/Database/Persist/GenericSql/Internal.hs b/Database/Persist/GenericSql/Internal.hs
--- a/Database/Persist/GenericSql/Internal.hs
+++ b/Database/Persist/GenericSql/Internal.hs
@@ -32,7 +32,7 @@
 import Database.Persist.EntityDef
 import qualified Data.Conduit as C
 import Language.Haskell.TH.Syntax (Q, Exp)
-import Control.Monad.Logger (logOther)
+import Control.Monad.Logger (logDebugS)
 import Data.Maybe (mapMaybe, listToMaybe)
 
 data Connection = Connection
@@ -194,4 +194,4 @@
 -}
 
 logSQL :: Q Exp
-logSQL = [|\sql_foo params_foo -> $(logOther "SQL") $ T.pack $ show (sql_foo :: Text) ++ " " ++ show (params_foo :: [PersistValue])|]
+logSQL = [|\sql_foo params_foo -> $logDebugS (T.pack "SQL") $ T.pack $ show (sql_foo :: Text) ++ " " ++ show (params_foo :: [PersistValue])|]
diff --git a/Database/Persist/GenericSql/Raw.hs b/Database/Persist/GenericSql/Raw.hs
--- a/Database/Persist/GenericSql/Raw.hs
+++ b/Database/Persist/GenericSql/Raw.hs
@@ -73,6 +73,7 @@
 
 instance MonadLogger m => MonadLogger (SqlPersist m) where
     monadLoggerLog a b c = lift $ monadLoggerLog a b c
+    monadLoggerLogSource a b c = lift . monadLoggerLogSource a b c
 
 withStmt :: (MonadSqlPersist m, MonadResource m)
          => Text
diff --git a/persistent.cabal b/persistent.cabal
--- a/persistent.cabal
+++ b/persistent.cabal
@@ -1,5 +1,5 @@
 name:            persistent
-version:         1.0.1.1
+version:         1.0.1.2
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -39,7 +39,7 @@
                    , pool-conduit             >= 0.1     && < 0.2
                    , path-pieces              >= 0.1     && < 0.2
                    , aeson                    >= 0.5     && < 0.7
-                   , monad-logger             >= 0.2     && < 0.3
+                   , monad-logger             >= 0.2.1   && < 0.3
                    , transformers-base
                    , base64-bytestring
                    , unordered-containers
@@ -78,10 +78,9 @@
     main-is:       test/main.hs
 
     build-depends:   base >= 4 && < 5
-                   , hspec
+                   , hspec >= 1.3
                    , containers
                    , text
-                   , HUnit
 
     cpp-options: -DTEST
 
diff --git a/test/main.hs b/test/main.hs
--- a/test/main.hs
+++ b/test/main.hs
@@ -1,16 +1,14 @@
 {-# LANGUAGE OverloadedStrings #-}
-import Test.Hspec.Monadic
-import Test.Hspec.HUnit ()
-import Test.HUnit
+import Test.Hspec
 
 import Database.Persist.Quasi
 import Database.Persist.EntityDef
 
 main :: IO ()
-main = hspecX $ do
+main = hspec $ do
     describe "tokenization" $ do
         it "handles normal words" $
-            tokenize " foo   bar  baz" @?=
+            tokenize " foo   bar  baz" `shouldBe`
                 [ Spaces 1
                 , Token "foo"
                 , Spaces 3
@@ -19,28 +17,28 @@
                 , Token "baz"
                 ]
         it "handles quotes" $
-            tokenize "  \"foo bar\"  \"baz\"" @?=
+            tokenize "  \"foo bar\"  \"baz\"" `shouldBe`
                 [ Spaces 2
                 , Token "foo bar"
                 , Spaces 2
                 , Token "baz"
                 ]
         it "handles unnested parantheses" $
-            tokenize "  (foo bar)  (baz)" @?=
+            tokenize "  (foo bar)  (baz)" `shouldBe`
                 [ Spaces 2
                 , Token "foo bar"
                 , Spaces 2
                 , Token "baz"
                 ]
         it "handles nested parantheses" $
-            tokenize "  (foo (bar))  (baz)" @?=
+            tokenize "  (foo (bar))  (baz)" `shouldBe`
                 [ Spaces 2
                 , Token "foo (bar)"
                 , Spaces 2
                 , Token "baz"
                 ]
         it "escaping " $
-            tokenize "  (foo \\(bar)  \"baz\\\"\"" @?=
+            tokenize "  (foo \\(bar)  \"baz\\\"\"" `shouldBe`
                 [ Spaces 2
                 , Token "foo (bar"
                 , Spaces 2
@@ -48,14 +46,14 @@
                 ]
     describe "parseFieldType" $ do
         it "simple types" $
-            parseFieldType "FooBar" @?= Just (FTTypeCon Nothing "FooBar")
+            parseFieldType "FooBar" `shouldBe` Just (FTTypeCon Nothing "FooBar")
         it "module types" $
-            parseFieldType "Data.Map.FooBar" @?= Just (FTTypeCon (Just "Data.Map") "FooBar")
+            parseFieldType "Data.Map.FooBar" `shouldBe` Just (FTTypeCon (Just "Data.Map") "FooBar")
         it "application" $
-            parseFieldType "Foo Bar" @?= Just (
+            parseFieldType "Foo Bar" `shouldBe` Just (
                 FTTypeCon Nothing "Foo" `FTApp` FTTypeCon Nothing "Bar")
         it "application multiple" $
-            parseFieldType "Foo Bar Baz" @?= Just (
+            parseFieldType "Foo Bar Baz" `shouldBe` Just (
                 (FTTypeCon Nothing "Foo" `FTApp` FTTypeCon Nothing "Bar")
                 `FTApp` FTTypeCon Nothing "Baz"
                 )
@@ -63,15 +61,15 @@
             let foo = FTTypeCon Nothing "Foo"
                 bar = FTTypeCon Nothing "Bar"
                 baz = FTTypeCon Nothing "Baz"
-            parseFieldType "Foo (Bar Baz)" @?= Just (
+            parseFieldType "Foo (Bar Baz)" `shouldBe` Just (
                 foo `FTApp` (bar `FTApp` baz))
         it "lists" $ do
             let foo = FTTypeCon Nothing "Foo"
                 bar = FTTypeCon Nothing "Bar"
                 bars = FTList bar
                 baz = FTTypeCon Nothing "Baz"
-            parseFieldType "Foo [Bar] Baz" @?= Just (
+            parseFieldType "Foo [Bar] Baz" `shouldBe` Just (
                 foo `FTApp` bars `FTApp` baz)
     describe "stripId" $ do
         it "works" $
-            (parseFieldType "FooId" >>= stripId) @?= Just "Foo"
+            (parseFieldType "FooId" >>= stripId) `shouldBe` Just "Foo"