diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,10 @@
+=1.0=
+* Changed the settings to use the Logger from http-server.
+* The default logger is now http-server's default logger.
+* Added extensive event logging.
+
+=0.9.1=
+* Packaging fixes
+
+=0.9=
+* Initial release.
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2012-2013 Stevens Institute of Technology
+Copyright (c) 2012-2014 Stevens Institute of Technology
 
 All rights reserved.
 
diff --git a/Network/HTTP/Proxy/Server.hs b/Network/HTTP/Proxy/Server.hs
--- a/Network/HTTP/Proxy/Server.hs
+++ b/Network/HTTP/Proxy/Server.hs
@@ -10,52 +10,80 @@
 import Network.HTTP.Server.Logger
 import Data.Default.Class
 import Network.HostName
+import Control.Monad.Reader
 
+-- | The proxy monad: Reader (for settings) over IO
+type Proxy s a = ReaderT (Settings s) IO a
+
+type ProxyResponse s = Proxy s (Response s)
+
 -- | Proxy entry-point. Spawns a new proxy server.
 proxyMain :: forall s. HStream s => Settings s -> IO ()
-proxyMain settings = 
-  do hname <- case hostname settings of
-       Nothing -> getHostName
+proxyMain settings = (`runReaderT` settings) $
+  do mhname <- asks hostname
+     hname <- case mhname of
+       Nothing -> lift getHostName
        Just hostn -> return hostn
-     let config = defaultConfig {srvPort = fromInteger $ portnum settings
+     log <- asks logger
+     port <- asks portnum
+     let config = defaultConfig {srvPort = fromInteger port
                                 ,srvHost = hname
-                                ,srvLog  = mylogger}
-     putStrLn "Proxy server started on port 3128\n"
-     serverWith config (proxyHandler settings)
-     
-mylogger = stdLogger
+                                ,srvLog  = log}
+     myLogInfo $ "Proxy server started on port " ++ (show port)
+     lift $ serverWith config (proxyHandler settings)
 
+myLogInfo :: String -> Proxy s ()
+myLogInfo s = asks logger >>= \l -> lift (logInfo l 0 s)
+
+myLogWarning :: String -> Proxy s ()
+myLogWarning s = asks logger >>= \l -> lift (logWarning l s)
+
+myLogError :: String -> Proxy s ()
+myLogError s = asks logger >>= \l -> lift (logError l s)
+
 proxyHandler :: HStream s => Settings s -> Handler s
-proxyHandler settings _ _ request = 
+proxyHandler settings _ _ request = (`runReaderT` settings) $ do
   -- check that the request is authorized
-  isAuthorized settings request >>= 
-  \authorized -> if authorized then processRequest settings request
-                 else errorProxyUnauthorized
-                      
--- |Processes the request; this is the main proxy procedure                     
-processRequest :: HStream s => Settings s -> Request s -> IO (Response s)
+  myLogInfo "Checking request authorization"
+  authorized <- lift $ isAuthorized settings request
+  if authorized then processRequest settings request
+                else do myLogWarning $ "Rejecting an unauthorized request: "
+                           ++ (show request)
+                        errorProxyUnauthorized
+
+-- | Processes the request; this is the main proxy procedure
+processRequest :: HStream s => Settings s -> Request s -> ProxyResponse s
 processRequest settings request = do
   -- modify the request
-  modRequest <- requestModifier settings request
+  myLogInfo "Modifying the request"
+  modRequest <- lift $ requestModifier settings request
   -- check the cache
-  mCachedResponse <- queryCache (cache settings) modRequest
+  myLogInfo "Querying cache"
+  mCachedResponse <- lift $ queryCache (cache settings) modRequest
   case mCachedResponse of
     -- found in cache: return
-    Just response -> return response
+    Just response -> do
+      myLogInfo "Cache hit: returning cached response"
+      return response
     -- not found: fetch it from a remote server, invoke the
     -- 'responseModifier' hook, record in cache and return
-    Nothing       -> do 
+    Nothing       -> do
+      myLogInfo "Cache miss: forwarding the request"
       response <- fetch request
-      modResponse <- responseModifier settings request response
-      recordInCache (cache settings) request modResponse 
+      myLogInfo "Modifying the response"
+      modResponse <- lift $ responseModifier settings request response
+      myLogInfo "Caching the modified response"
+      lift $ recordInCache (cache settings) request modResponse 
       return modResponse
       
-fetch :: HStream s => Request s -> IO (Response s)
+fetch :: HStream s => Request s -> ProxyResponse s
 fetch request = do
-  result <- simpleHTTP request
+  result <- lift $ simpleHTTP request
   case result of 
-    Left err  -> do putStrLn ("Connection error: " ++ show err)
-                    errorInternalServerError
+    Left err  -> do myLogError $
+                      "Connection error while fetching an external resource: "
+                      ++ show err
+                    lift errorInternalServerError
     Right rsp -> return rsp
     
 -- | Proxy server settings                
@@ -75,8 +103,9 @@
            ,isAuthorized     :: Request s -> IO Bool
             -- ^ Authorization function. Allows denying certain
             -- requests. Defaults to allowing all requests
-           ,logger           :: String -> IO ()
-            -- ^ A logging function. The default is no logging.
+           ,logger           :: Logger
+            -- ^ A logging function. The default is 'stdLogger' from
+            -- http-server.
            ,portnum          :: Integer
             -- ^ Proxy server port number; default is 3128
            ,hostname         :: Maybe String
@@ -89,7 +118,7 @@
                  ,responseModifier = \_ -> return
                  ,cache            = def
                  ,isAuthorized     = return . const True
-                 ,logger           = \_ -> return ()
+                 ,logger           = stdLogger
                  ,portnum          = 3128
                  ,hostname         = Nothing}
 
@@ -112,7 +141,7 @@
 
 -- |A generic 407 response. TODO: RFC 2068 requres to send
 -- Proxy-Authenticate header with this response code
-errorProxyUnauthorized :: HStream s => IO (Response s)
+errorProxyUnauthorized :: HStream s => ProxyResponse s
 errorProxyUnauthorized = return $ err_response ProxyAuthenticationRequired
 
 -- |A generic 400 response
diff --git a/haxy.cabal b/haxy.cabal
--- a/haxy.cabal
+++ b/haxy.cabal
@@ -1,5 +1,5 @@
 Name:                haxy
-Version:             0.9.1
+Version:             1.0
 Synopsis:            A simple HTTP proxy server library
 Description:         A library for writing HTTP proxy servers with the focus on simplicity, flexibility and modularity. Allows arbitrary transformations on requests and responses and custom caching methods. It's up to the user to make sure that the message transformations are consistent with the HTTP specification. The executable program is a simple non-caching identity proxy and is used for testing the library.
 License:             BSD3
@@ -8,11 +8,13 @@
 Maintainer:          Andrey Chudnov <oss@chudnov.com>
 Homepage:            http://github.com/achudnov/haxy
 Bug-reports:         http://github.com/achudnov/haxy/issues
-Copyright:           (c) 2012-2013 Stevens Institute of Technology
+Copyright:           (c) 2012-2014 Stevens Institute of Technology
 Category:            Web
 Build-type:          Simple
 Stability:           Stable
 Cabal-version:       >=1.10
+Extra-Source-Files:  CHANGELOG
+Tested-with:         GHC==7.6.3, GHC==7.4.2, GHC==7.8.2
 
 source-repository head
    type: git
@@ -21,25 +23,16 @@
 source-repository this
    type: git
    location: git://github.com/achudnov/haxy.git
-   tag: 0.9.1
+   tag: 1.0
 
 Library
   Exposed-modules: Network.HTTP.Proxy.Server
-  Build-depends: http-server  >= 1.0.3 && < 1.1
+  Build-depends: http-server  >= 1.0.4 && < 1.1
                , HTTP         >= 4000.2.0 && < 5000
                , base         >= 4.3.1.0 && < 5
                , url          >= 2.1.2 && < 2.2
                , bytestring   >= 0.9 && < 0.11
                , data-default-class >= 0.0.1 && < 0.1
                , hostname     >= 1.0 && < 2
+               , mtl          == 2.*
   Default-Language: Haskell2010
-
-Executable simple-proxy
-   Main-Is: test/IdProxy.hs
-   Build-Depends: base         >= 4.3.1.0 && < 5
-                , bytestring   >= 0.9 && < 0.11
-                , data-default-class >= 0.0.1 && < 0.1
-                , hostname     >= 1.0 && < 2
-                , http-server  >= 1.0.3 && < 1.1
-                , HTTP         >= 4000.2.0 && < 5000
-   Default-Language: Haskell2010
diff --git a/test/IdProxy.hs b/test/IdProxy.hs
deleted file mode 100644
--- a/test/IdProxy.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Main where
-
-import Network.HTTP.Proxy.Server
-import Data.Default.Class
-import Data.ByteString
-
-main = proxyMain (def :: Settings ByteString) {hostname = Just "localhost"}