Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package ghc-fast-logger for openSUSE:Factory
checked in at 2022-02-11 23:08:48
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-fast-logger (Old)
and /work/SRC/openSUSE:Factory/.ghc-fast-logger.new.1956 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-fast-logger"
Fri Feb 11 23:08:48 2022 rev:26 rq:953455 version:3.1.1
Changes:
--------
--- /work/SRC/openSUSE:Factory/ghc-fast-logger/ghc-fast-logger.changes
2021-05-05 20:40:54.258679659 +0200
+++
/work/SRC/openSUSE:Factory/.ghc-fast-logger.new.1956/ghc-fast-logger.changes
2022-02-11 23:10:44.839178129 +0100
@@ -1,0 +2,14 @@
+Thu Jan 20 07:53:07 UTC 2022 - Peter Simons <[email protected]>
+
+- Update fast-logger to version 3.1.1.
+ ## 3.1.1
+
+ * More time-ordered logging functions
+ [#199](https://github.com/kazu-yamamoto/logger/pull/199
+
+ ## 3.1.0
+
+ * Having a single Buffer in LoggerSet for locking
[#197](https://github.com/kazu-yamamoto/logger/pull/197.
+ This would have performance penalty. So, the major version bumps up. If
you see performance regression, please register an issue on github.
+
+-------------------------------------------------------------------
Old:
----
fast-logger-3.0.5.tar.gz
New:
----
fast-logger-3.1.1.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ ghc-fast-logger.spec ++++++
--- /var/tmp/diff_new_pack.rhRNnF/_old 2022-02-11 23:10:45.355179622 +0100
+++ /var/tmp/diff_new_pack.rhRNnF/_new 2022-02-11 23:10:45.359179633 +0100
@@ -1,7 +1,7 @@
#
# spec file for package ghc-fast-logger
#
-# Copyright (c) 2021 SUSE LLC
+# Copyright (c) 2022 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -19,7 +19,7 @@
%global pkg_name fast-logger
%bcond_with tests
Name: ghc-%{pkg_name}
-Version: 3.0.5
+Version: 3.1.1
Release: 0
Summary: A fast logging system
License: BSD-3-Clause
++++++ fast-logger-3.0.5.tar.gz -> fast-logger-3.1.1.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/fast-logger-3.0.5/ChangeLog.md
new/fast-logger-3.1.1/ChangeLog.md
--- old/fast-logger-3.0.5/ChangeLog.md 2021-04-30 07:48:58.000000000 +0200
+++ new/fast-logger-3.1.1/ChangeLog.md 2001-09-09 03:46:40.000000000 +0200
@@ -1,3 +1,13 @@
+## 3.1.1
+
+* More time-ordered logging functions
+ [#199](https://github.com/kazu-yamamoto/logger/pull/199
+
+## 3.1.0
+
+* Having a single Buffer in LoggerSet for locking
[#197](https://github.com/kazu-yamamoto/logger/pull/197.
+ This would have performance penalty. So, the major version bumps up. If you
see performance regression, please register an issue on github.
+
## 3.0.5
* recovering backward compatibility for newFileLoggerSet.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/fast-logger-3.0.5/System/Log/FastLogger/IO.hs
new/fast-logger-3.1.1/System/Log/FastLogger/IO.hs
--- old/fast-logger-3.0.5/System/Log/FastLogger/IO.hs 2021-04-30
07:48:58.000000000 +0200
+++ new/fast-logger-3.1.1/System/Log/FastLogger/IO.hs 2001-09-09
03:46:40.000000000 +0200
@@ -1,4 +1,3 @@
-{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ <= 708
@@ -34,7 +33,7 @@
freeBuffer = free
toBufIOWith :: Buffer -> BufSize -> (Buffer -> Int -> IO ()) -> Builder -> IO
()
-toBufIOWith buf !size io builder = loop $ BBE.runBuilder builder
+toBufIOWith buf size io builder = loop $ BBE.runBuilder builder
where
loop writer = do
(len, next) <- writer buf size
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/fast-logger-3.0.5/System/Log/FastLogger/Logger.hs
new/fast-logger-3.1.1/System/Log/FastLogger/Logger.hs
--- old/fast-logger-3.0.5/System/Log/FastLogger/Logger.hs 2021-04-30
07:48:58.000000000 +0200
+++ new/fast-logger-3.1.1/System/Log/FastLogger/Logger.hs 2001-09-09
03:46:40.000000000 +0200
@@ -1,4 +1,3 @@
-{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE Safe #-}
@@ -10,7 +9,7 @@
) where
-import Control.Concurrent (MVar, newMVar, withMVar)
+import Control.Concurrent (MVar, withMVar)
import Foreign.Marshal.Alloc (allocaBytes)
import Foreign.Ptr (plusPtr)
@@ -21,20 +20,19 @@
----------------------------------------------------------------
-data Logger = Logger !BufSize (MVar Buffer) (IORef LogStr)
+newtype Logger = Logger (IORef LogStr)
----------------------------------------------------------------
-newLogger :: BufSize -> IO Logger
-newLogger size = Logger size <$> (getBuffer size >>= newMVar)
- <*> newIORef mempty
+newLogger :: IO Logger
+newLogger = Logger <$> newIORef mempty
----------------------------------------------------------------
-pushLog :: IORef FD -> Logger -> LogStr -> IO ()
-pushLog fdref logger@(Logger size mbuf ref) nlogmsg@(LogStr nlen nbuilder)
+pushLog :: IORef FD -> BufSize -> MVar Buffer -> Logger -> LogStr -> IO ()
+pushLog fdref size mbuf logger@(Logger ref) nlogmsg@(LogStr nlen nbuilder)
| nlen > size = do
- flushLog fdref logger
+ flushLog fdref size mbuf logger
-- Make sure we have a large enough buffer to hold the entire
-- contents, thereby allowing for a single write system call and
-- avoiding interleaving. This does not address the possibility
@@ -53,8 +51,8 @@
----------------------------------------------------------------
-flushLog :: IORef FD -> Logger -> IO ()
-flushLog fdref (Logger size mbuf lref) = do
+flushLog :: IORef FD -> BufSize -> MVar Buffer -> Logger -> IO ()
+flushLog fdref size mbuf (Logger lref) = do
logmsg <- atomicModifyIORef' lref (\old -> (mempty, old))
-- If a special buffer is prepared for flusher, this MVar could
-- be removed. But such a code does not contribute logging speed
@@ -81,7 +79,7 @@
write :: IORef FD -> Buffer -> Int -> IO ()
write fdref buf len' = loop buf (fromIntegral len')
where
- loop bf !len = do
+ loop bf len = do
written <- writeRawBufferPtr2FD fdref bf len
when (0 <= written && written < len) $
loop (bf `plusPtr` fromIntegral written) (len - written)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/fast-logger-3.0.5/System/Log/FastLogger/LoggerSet.hs
new/fast-logger-3.1.1/System/Log/FastLogger/LoggerSet.hs
--- old/fast-logger-3.0.5/System/Log/FastLogger/LoggerSet.hs 2021-04-30
07:48:58.000000000 +0200
+++ new/fast-logger-3.1.1/System/Log/FastLogger/LoggerSet.hs 2001-09-09
03:46:40.000000000 +0200
@@ -6,8 +6,11 @@
, newFileLoggerSet
, newFileLoggerSetN
, newStdoutLoggerSet
+ , newStdoutLoggerSetN
, newStderrLoggerSet
+ , newStderrLoggerSetN
, newLoggerSet
+ , newFDLoggerSet
-- * Renewing and removing a logger set
, renewLoggerSet
, rmLoggerSet
@@ -20,8 +23,8 @@
, replaceLoggerSet
) where
+import Control.Concurrent (MVar, getNumCapabilities, myThreadId,
threadCapability, takeMVar, newMVar)
import Control.Debounce (mkDebounce, defaultDebounceSettings, debounceAction)
-import Control.Concurrent (getNumCapabilities, myThreadId, threadCapability,
takeMVar)
import Data.Array (Array, listArray, (!), bounds)
import System.Log.FastLogger.FileIO
@@ -36,13 +39,22 @@
-- The number of loggers is the capabilities of GHC RTS.
-- You can specify it with \"+RTS -N\<x\>\".
-- A buffer is prepared for each capability.
-data LoggerSet = LoggerSet (Maybe FilePath) (IORef FD) (Array Int Logger) (IO
())
+data LoggerSet = LoggerSet (Maybe FilePath) (IORef FD)
+ BufSize (MVar Buffer)
+ (Array Int Logger)
+ (IO ())
-- | Creating a new 'LoggerSet' using a file.
+--
+-- Uses `numCapabilties` many buffers, which will result in log
+-- output that is not ordered by time (see `newFileLoggerSetN`).
newFileLoggerSet :: BufSize -> FilePath -> IO LoggerSet
newFileLoggerSet size file = openFileFD file >>= newFDLoggerSet size Nothing
(Just file)
--- | Creating a new 'LoggerSet' using a file.
+-- | Creating a new 'LoggerSet' using a file, using only the given number of
capabilites.
+--
+-- Giving @mn = Just 1@ scales less well on multi-core machines,
+-- but provides time-ordered output.
newFileLoggerSetN :: BufSize -> Maybe Int -> FilePath -> IO LoggerSet
newFileLoggerSetN size mn file = openFileFD file >>= newFDLoggerSet size mn
(Just file)
@@ -50,10 +62,20 @@
newStdoutLoggerSet :: BufSize -> IO LoggerSet
newStdoutLoggerSet size = getStdoutFD >>= newFDLoggerSet size Nothing Nothing
+-- | Creating a new 'LoggerSet' using stdout, with the given number of buffers
+-- (see `newFileLoggerSetN`).
+newStdoutLoggerSetN :: BufSize -> Maybe Int -> IO LoggerSet
+newStdoutLoggerSetN size mn = getStdoutFD >>= newFDLoggerSet size mn Nothing
+
-- | Creating a new 'LoggerSet' using stderr.
newStderrLoggerSet :: BufSize -> IO LoggerSet
newStderrLoggerSet size = getStderrFD >>= newFDLoggerSet size Nothing Nothing
+-- | Creating a new 'LoggerSet' using stderr, with the given number of buffers
+-- (see `newFileLoggerSetN`).
+newStderrLoggerSetN :: BufSize -> Maybe Int -> IO LoggerSet
+newStderrLoggerSetN size mn = getStderrFD >>= newFDLoggerSet size mn Nothing
+
{-# DEPRECATED newLoggerSet "Use newFileLoggerSet etc instead" #-}
-- | Creating a new 'LoggerSet'.
-- If 'Nothing' is specified to the second argument,
@@ -68,19 +90,21 @@
n <- case mn of
Just n' -> return n'
Nothing -> getNumCapabilities
- loggers <- replicateM n $ newLogger (max 1 size)
+ loggers <- replicateM n newLogger
let arr = listArray (0,n-1) loggers
fref <- newIORef fd
+ let bufsiz = max 1 size
+ mbuf <- getBuffer bufsiz >>= newMVar
flush <- mkDebounce defaultDebounceSettings
- { debounceAction = flushLogStrRaw fref arr
+ { debounceAction = flushLogStrRaw fref bufsiz mbuf arr
}
- return $ LoggerSet mfile fref arr flush
+ return $ LoggerSet mfile fref bufsiz mbuf arr flush
-- | Writing a log message to the corresponding buffer.
-- If the buffer becomes full, the log messages in the buffer
-- are written to its corresponding file, stdout, or stderr.
pushLogStr :: LoggerSet -> LogStr -> IO ()
-pushLogStr (LoggerSet _ fdref arr flush) logmsg = do
+pushLogStr (LoggerSet _ fdref size mbuf arr flush) logmsg = do
(i, _) <- myThreadId >>= threadCapability
-- The number of capability could be dynamically changed.
-- So, let's check the upper boundary of the array.
@@ -89,7 +113,7 @@
j | i < lim = i
| otherwise = i `mod` lim
let logger = arr ! j
- pushLog fdref logger logmsg
+ pushLog fdref size mbuf logger logmsg
flush
-- | Same as 'pushLogStr' but also appends a newline.
@@ -106,20 +130,20 @@
-- function can be used to force flushing outside of the debounced
-- flush calls.
flushLogStr :: LoggerSet -> IO ()
-flushLogStr (LoggerSet _ fref arr _) = flushLogStrRaw fref arr
+flushLogStr (LoggerSet _ fref size mbuf arr _) = flushLogStrRaw fref size mbuf
arr
-flushLogStrRaw :: IORef FD -> Array Int Logger -> IO ()
-flushLogStrRaw fdref arr = do
+flushLogStrRaw :: IORef FD -> BufSize -> MVar Buffer -> Array Int Logger -> IO
()
+flushLogStrRaw fdref size mbuf arr = do
let (l,u) = bounds arr
mapM_ flushIt [l .. u]
where
- flushIt i = flushLog fdref (arr ! i)
+ flushIt i = flushLog fdref size mbuf (arr ! i)
-- | Renewing the internal file information in 'LoggerSet'.
-- This does nothing for stdout and stderr.
renewLoggerSet :: LoggerSet -> IO ()
-renewLoggerSet (LoggerSet Nothing _ _ _) = return ()
-renewLoggerSet (LoggerSet (Just file) fref _ _) = do
+renewLoggerSet (LoggerSet Nothing _ _ _ _ _) = return ()
+renewLoggerSet (LoggerSet (Just file) fref _ _ _ _) = do
newfd <- openFileFD file
oldfd <- atomicModifyIORef' fref (\fd -> (newfd, fd))
closeFD oldfd
@@ -127,23 +151,20 @@
-- | Flushing the buffers, closing the internal file information
-- and freeing the buffers.
rmLoggerSet :: LoggerSet -> IO ()
-rmLoggerSet (LoggerSet mfile fdref arr _) = do
+rmLoggerSet (LoggerSet mfile fdref size mbuf arr _) = do
fd <- readIORef fdref
when (isFDValid fd) $ do
let (l,u) = bounds arr
let nums = [l .. u]
mapM_ flushIt nums
- mapM_ freeIt nums
+ takeMVar mbuf >>= freeBuffer
when (isJust mfile) $ closeFD fd
writeIORef fdref invalidFD
where
- flushIt i = flushLog fdref (arr ! i)
- freeIt i = do
- let (Logger _ mbuf _) = arr ! i
- takeMVar mbuf >>= freeBuffer
+ flushIt i = flushLog fdref size mbuf(arr ! i)
-- | Replacing the file path in 'LoggerSet' and returning a new
-- 'LoggerSet' and the old file path.
replaceLoggerSet :: LoggerSet -> FilePath -> (LoggerSet, Maybe FilePath)
-replaceLoggerSet (LoggerSet current_path a b c) new_file_path =
- (LoggerSet (Just new_file_path) a b c, current_path)
+replaceLoggerSet (LoggerSet current_path a b c d e) new_file_path =
+ (LoggerSet (Just new_file_path) a b c d e, current_path)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/fast-logger-3.0.5/System/Log/FastLogger.hs
new/fast-logger-3.1.1/System/Log/FastLogger.hs
--- old/fast-logger-3.0.5/System/Log/FastLogger.hs 2021-04-30
07:48:58.000000000 +0200
+++ new/fast-logger-3.1.1/System/Log/FastLogger.hs 2001-09-09
03:46:40.000000000 +0200
@@ -101,17 +101,24 @@
-- This type signature should be read as:
--
-- > newFastLogger :: LogType -> IO (FastLogger, IO ())
+--
+-- This logger uses `numCapabilities` many buffers, and thus
+-- does not provide time-ordered output.
+-- For time-ordered output, use `newFastLogger1`.
newFastLogger :: LogType' v -> IO (v -> IO (), IO ())
newFastLogger typ = newFastLoggerCore Nothing typ
+-- | Like `newFastLogger`, but creating a logger that uses only 1
+-- capability. This scales less well on multi-core machines,
+-- but provides time-ordered output.
newFastLogger1 :: LogType' v -> IO (v -> IO (), IO ())
newFastLogger1 typ = newFastLoggerCore (Just 1) typ
newFastLoggerCore :: Maybe Int -> LogType' v -> IO (v -> IO (), IO ())
newFastLoggerCore mn typ = case typ of
LogNone -> return (const noOp, noOp)
- LogStdout bsize -> newStdoutLoggerSet bsize >>=
stdLoggerInit
- LogStderr bsize -> newStderrLoggerSet bsize >>=
stdLoggerInit
+ LogStdout bsize -> newStdoutLoggerSetN bsize mn >>=
stdLoggerInit
+ LogStderr bsize -> newStderrLoggerSetN bsize mn >>=
stdLoggerInit
LogFileNoRotate fp bsize -> newFileLoggerSetN bsize mn fp >>=
fileLoggerInit
LogFile fspec bsize -> rotateLoggerInit fspec bsize
LogFileTimedRotate fspec bsize -> timedRotateLoggerInit fspec bsize
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/fast-logger-3.0.5/fast-logger.cabal
new/fast-logger-3.1.1/fast-logger.cabal
--- old/fast-logger-3.0.5/fast-logger.cabal 2021-04-30 07:48:58.000000000
+0200
+++ new/fast-logger-3.1.1/fast-logger.cabal 2001-09-09 03:46:40.000000000
+0200
@@ -1,5 +1,5 @@
Name: fast-logger
-Version: 3.0.5
+Version: 3.1.1
Author: Kazu Yamamoto <[email protected]>
Maintainer: Kazu Yamamoto <[email protected]>
License: BSD3
