diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,6 @@
+# log-base-0.11.0.0 (2021-10-11)
+* Add support for defining maximum log level.
+
 # log-base-0.10.0.1 (2021-07-29)
 * Fix compilation issues caused by ambiguos occurence of `controlT`.
 
diff --git a/log-base.cabal b/log-base.cabal
--- a/log-base.cabal
+++ b/log-base.cabal
@@ -1,5 +1,5 @@
 name:                log-base
-version:             0.10.0.1
+version:             0.11.0.0
 synopsis:            Structured logging solution (base package)
 
 description:         A library that provides a way to record structured log
@@ -40,7 +40,7 @@
                        Log.Logger,
                        Log.Monad
   build-depends:       base >= 4.9 && <5,
-                       aeson >=0.11.0.0,
+                       aeson >=0.11.0.0 && <1.6,
                        aeson-pretty >=0.8.2,
                        bytestring,
                        deepseq,
diff --git a/src/Log.hs b/src/Log.hs
--- a/src/Log.hs
+++ b/src/Log.hs
@@ -18,7 +18,7 @@
 --         esMapping = "log"
 --         }
 --   'Log.Backend.ElasticSearch.withElasticSearchLogger' config randomIO $ \\logger -> do
---     'runLogT' "main" logger $ do
+--     'runLogT' "main" logger defaultLogLevel $ do
 --       'logTrace_' "foo"
 -- @
 module Log (
diff --git a/src/Log/Class.hs b/src/Log/Class.hs
--- a/src/Log/Class.hs
+++ b/src/Log/Class.hs
@@ -36,6 +36,8 @@
   localData   :: [Pair] -> m a -> m a
   -- | Extend the current application domain locally.
   localDomain :: T.Text -> m a -> m a
+  -- | Override the current maximum log level.
+  localMaxLogLevel :: LogLevel -> m a -> m a
   -- | Get current 'LoggerEnv' object. Useful for construction of logging
   -- functions that work in a different monad, see 'getLoggerIO' as an example.
   getLoggerEnv :: m LoggerEnv
@@ -49,6 +51,7 @@
     logMessage level message = lift . logMessage level message
     localData data_ m = controlT $ \run -> localData data_ (run m)
     localDomain domain m = controlT $ \run -> localDomain domain (run m)
+    localMaxLogLevel level m = controlT $ \run -> localMaxLogLevel level (run m)
     getLoggerEnv = lift getLoggerEnv
 
 ----------------------------------------
diff --git a/src/Log/Data.hs b/src/Log/Data.hs
--- a/src/Log/Data.hs
+++ b/src/Log/Data.hs
@@ -3,8 +3,10 @@
     LogLevel(..)
   , showLogLevel
   , readLogLevel
+  , readLogLevelEither
   , LogMessage(..)
   , showLogMessage
+  , defaultLogLevel
   ) where
 
 import Control.DeepSeq
@@ -20,6 +22,8 @@
 import qualified Data.Monoid as Monoid
 
 -- | Available log levels.
+-- Note that ordering in this definintion determines what the maximum log level is.
+-- See 'Log.Monad.leMaxLogLevel'.
 data LogLevel = LogAttention | LogInfo | LogTrace
   deriving (Bounded, Eq, Ord, Show)
 
@@ -39,6 +43,10 @@
 showLogLevel LogAttention = "attention"
 showLogLevel LogInfo      = "info"
 showLogLevel LogTrace     = "trace"
+
+-- | The default log level. Returns `LogInfo`.
+defaultLogLevel :: LogLevel
+defaultLogLevel = LogInfo
 
 instance ToJSON LogLevel where
   toJSON = toJSON . showLogLevel
diff --git a/src/Log/Logger.hs b/src/Log/Logger.hs
--- a/src/Log/Logger.hs
+++ b/src/Log/Logger.hs
@@ -32,6 +32,7 @@
   , leDomain    :: ![T.Text] -- ^ Current application domain.
   , leData      :: ![A.Pair] -- ^ Additional data to be merged with the log
                              -- message\'s data.
+  , leMaxLogLevel :: LogLevel -- ^ The maximum log level allowed to be logged.
   }
 
 -- | Start a logger thread that consumes one queued message at a time.
@@ -80,7 +81,7 @@
 -- main = do
 --    logger \<- 'Log.Backend.ElasticSearch.elasticSearchLogger'
 --    a \<- 'Control.Concurrent.Async.async' ('Log.Backend.ElasticSearch.withElasticSearchLogger' $ \\logger ->
---                'Log.Monad.runLogT' "main" logger $ 'Log.Class.logTrace_' "foo")
+--                'Log.Monad.runLogT' "main" logger defaultLogLevel $ 'Log.Class.logTrace_' "foo")
 --    -- Main thread exits without waiting for the child
 --    -- to finish and without giving the child a chance
 --    -- to do proper cleanup.
@@ -95,7 +96,7 @@
 -- main = do
 --    logger \<- 'Log.Backend.ElasticSearch.elasticSearchLogger'
 --    a \<- 'Control.Concurrent.Async.async' ('Log.Backend.ElasticSearch.withElasticSearchLogger' $ \\logger ->
---                'Log.Monad.runLogT' "main" logger $ 'Log.Class.logTrace_' "foo")
+--                'Log.Monad.runLogT' "main" logger defaultLogLevel $ 'Log.Class.logTrace_' "foo")
 --    'Control.Concurrent.Async.wait' a
 --    -- Main thread waits for the child to finish, giving
 --    -- it a chance to shut down properly. This works even
diff --git a/src/Log/Monad.hs b/src/Log/Monad.hs
--- a/src/Log/Monad.hs
+++ b/src/Log/Monad.hs
@@ -54,13 +54,16 @@
 -- for that.
 runLogT :: Text     -- ^ Application component name to use.
         -> Logger   -- ^ The logging back-end to use.
+        -> LogLevel -- ^ The maximum log level allowed to be logged.
+                    --   Only messages less or equal than this level with be logged.
         -> LogT m a -- ^ The 'LogT' computation to run.
         -> m a
-runLogT component logger m = runReaderT (unLogT m) LoggerEnv {
+runLogT component logger maxLogLevel m = runReaderT (unLogT m) LoggerEnv {
   leLogger = logger
 , leComponent = component
 , leDomain = []
 , leData = []
+, leMaxLogLevel = maxLogLevel
 } -- We can't do synchronisation here, since 'runLogT' can be invoked
   -- quite often from the application (e.g. on every request).
 
@@ -72,7 +75,8 @@
 -- 'LoggerEnv'. Useful for reimplementation of 'MonadLog' instance.
 logMessageIO :: LoggerEnv -> UTCTime -> LogLevel -> Text -> Value -> IO ()
 logMessageIO LoggerEnv{..} time level message data_ =
-  execLogger leLogger =<< E.evaluate (force lm)
+  when (level <= leMaxLogLevel) $
+    execLogger leLogger =<< E.evaluate (force lm)
   where
     lm = LogMessage
       { lmComponent = leComponent
@@ -150,5 +154,8 @@
 
   localDomain domain =
     LogT . local (\e -> e { leDomain = leDomain e ++ [domain] }) . unLogT
+
+  localMaxLogLevel level =
+    LogT . local (\e -> e { leMaxLogLevel = level }) . unLogT
 
   getLoggerEnv = LogT ask