drop document_io_logring.txt and use global logging

Change-Id: Ibda0ce925bc76355e636022c955077ac89e66cce
Reviewed-on: https://gerrit.libreoffice.org/36434
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

21 files changed, 366 insertions, 850 deletions

diff --git a/include/sfx2/docfile.hxx b/include/sfx2/docfile.hxx
index 07cfbe119c5b..c695a127b4f8 100644
--- a/include/sfx2/docfile.hxx
+++ b/include/sfx2/docfile.hxx
@@ -145,9 +145,7 @@ public:
                         { return ERRCODE_TOERROR(GetErrorCode()); }
     sal_uInt32          GetLastStorageCreationState();
 
-    void                SetError( sal_uInt32 nError, const OUString& aLogMessage );
-
-    void                AddLog( const OUString& aMessage );
+    void                SetError(sal_uInt32 nError);
 
     void                CloseInStream();
     bool                CloseOutStream();
diff --git a/include/sfx2/objsh.hxx b/include/sfx2/objsh.hxx
index 716da53f9db3..654720aad1a9 100644
--- a/include/sfx2/objsh.hxx
+++ b/include/sfx2/objsh.hxx
@@ -303,10 +303,7 @@ public:
     void                        ResetError();
     sal_uInt32                  GetError() const;
     sal_uInt32                  GetErrorCode() const;
-    void                        SetError( sal_uInt32 rErr, const OUString& aLogMessage );
-
-    void                        AddLog( const OUString& aMessage );
-    void                        StoreLog();
+    void                        SetError(sal_uInt32 rErr);
 
     /**
      * Initialize bare minimum just enough for unit test runs.
diff --git a/package/inc/pch/precompiled_xstor.hxx b/package/inc/pch/precompiled_xstor.hxx
index 941d290cbffa..6976db7f1b77 100644
--- a/package/inc/pch/precompiled_xstor.hxx
+++ b/package/inc/pch/precompiled_xstor.hxx
@@ -64,7 +64,6 @@
 #include <com/sun/star/lang/XSingleComponentFactory.hpp>
 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
 #include <com/sun/star/lang/XUnoTunnel.hpp>
-#include <com/sun/star/logging/DocumentIOLogRing.hpp>
 #include <com/sun/star/registry/XRegistryKey.hpp>
 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
 #include <com/sun/star/uno/Any.h>
diff --git a/package/source/xstor/owriteablestream.cxx b/package/source/xstor/owriteablestream.cxx
index a2c37e1ade42..725cf810d877 100644
--- a/package/source/xstor/owriteablestream.cxx
+++ b/package/source/xstor/owriteablestream.cxx
@@ -26,7 +26,6 @@
 #include <com/sun/star/lang/DisposedException.hpp>
 #include <com/sun/star/lang/XUnoTunnel.hpp>
 #include <com/sun/star/lang/XTypeProvider.hpp>
-#include <com/sun/star/logging/DocumentIOLogRing.hpp>
 #include <com/sun/star/io/NotConnectedException.hpp>
 #include <com/sun/star/io/TempFile.hpp>
 #include <com/sun/star/io/XInputStream.hpp>
@@ -333,25 +332,6 @@ void OWriteStream_Impl::CleanCacheStream()
     }
 }
 
-void OWriteStream_Impl::AddLog( const OUString& aMessage )
-{
-    if ( !m_xLogRing.is() )
-    {
-        try
-        {
-            uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
-            m_xLogRing = logging::DocumentIOLogRing::get(xContext);
-        }
-        catch( const uno::Exception& )
-        {
-            // No log
-        }
-    }
-
-    if ( m_xLogRing.is() )
-        m_xLogRing->logString( aMessage );
-}
-
 void OWriteStream_Impl::InsertIntoPackageFolder( const OUString& aName,
                                                   const uno::Reference< container::XNameContainer >& xParentPackageFolder )
 {
@@ -489,8 +469,7 @@ void OWriteStream_Impl::DisposeWrappers()
         }
         catch ( const uno::RuntimeException& rRuntimeException )
         {
-            AddLog( rRuntimeException.Message );
-            AddLog( "Quiet exception" );
+            SAL_INFO("package.xstor", "Quiet exception: " << rRuntimeException.Message);
         }
 
         m_pAntiImpl = nullptr;
@@ -538,19 +517,15 @@ OUString const & OWriteStream_Impl::GetFilledTempFileIfNo( const uno::Reference<
         }
         catch( const packages::WrongPasswordException& rWrongPasswordException )
         {
-            AddLog( rWrongPasswordException.Message );
-            AddLog( "Rethrow" );
-
+            SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
             KillFile( aTempURL, comphelper::getProcessComponentContext() );
             throw;
         }
         catch( const uno::Exception& rException )
         {
-            AddLog( rException.Message );
-            AddLog( "Rethrow" );
-
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
             KillFile( aTempURL, comphelper::getProcessComponentContext() );
-        throw;
+            throw;
         }
 
         if ( !aTempURL.isEmpty() )
@@ -661,8 +636,7 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetTempFileAsStream()
             }
             catch( const uno::Exception& rException )
             {
-                AddLog( rException.Message );
-                AddLog( "Quiet exception" );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
         }
     }
@@ -699,8 +673,7 @@ uno::Reference< io::XInputStream > OWriteStream_Impl::GetTempFileAsInputStream()
             }
             catch( const uno::Exception& rException )
             {
-                AddLog( rException.Message );
-                AddLog( "Quiet exception" );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
         }
     }
@@ -1038,8 +1011,7 @@ void OWriteStream_Impl::ReadRelInfoIfNecessary()
         }
         catch( const uno::Exception& rException )
         {
-            AddLog( rException.Message );
-            AddLog( "Quiet exception" );
+            SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
 
             m_nRelInfoStatus = RELINFO_BROKEN;
             m_bOrigRelInfoBroken = true;
@@ -1104,9 +1076,7 @@ uno::Sequence< beans::PropertyValue > OWriteStream_Impl::ReadPackageStreamProper
         }
         catch( const uno::Exception& rException )
         {
-            AddLog( rException.Message );
-            AddLog( "Quiet exception" );
-
+            SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             SAL_WARN( "package.xstor", "A property can't be retrieved!" );
         }
     }
@@ -1213,15 +1183,12 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMod
         catch( const packages::WrongPasswordException& rWrongPasswordException )
         {
             SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
-            AddLog( rWrongPasswordException.Message );
-            AddLog( "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
             throw;
         }
         catch ( const uno::Exception& rException )
         {
-            AddLog( rException.Message );
-            AddLog( "Quiet exception" );
-
+            SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             SAL_WARN( "package.xstor", "Can't write encryption related properties!" );
             SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
             throw io::IOException(); // TODO:
@@ -1253,9 +1220,7 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMod
         }
         catch( const packages::NoEncryptionException& rNoEncryptionException )
         {
-            AddLog( rNoEncryptionException.Message );
-            AddLog( "Rethrow" );
-
+            SAL_INFO("package.xstor", "Rethrow: " << rNoEncryptionException.Message);
             throw packages::WrongPasswordException();
         }
 
@@ -1476,9 +1441,7 @@ void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTar
         }
         catch( const packages::NoEncryptionException& rNoEncryptionException )
         {
-            AddLog( rNoEncryptionException.Message );
-            AddLog( "No Element" );
-
+            SAL_INFO("package.xstor", "No Element: " << rNoEncryptionException.Message);
             throw packages::WrongPasswordException();
         }
 
@@ -1547,8 +1510,7 @@ void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTar
         {
             SAL_WARN( "package.xstor", "Can't open encrypted stream!" );
             SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
-            AddLog( rException.Message );
-            AddLog( "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
             throw;
         }
 
@@ -1714,8 +1676,7 @@ OWriteStream::~OWriteStream()
         }
         catch( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( "Quiet exception" );
+            SAL_INFO("package.xstor", "Quiet exception: " << rRuntimeException.Message);
         }
     }
 }
@@ -1798,9 +1759,7 @@ void OWriteStream::CopyToStreamInternally_Impl( const uno::Reference< io::XStrea
     }
     catch ( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( "Quiet exception" );
-
+        SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
         // TODO: set the stream in invalid state or dispose
         SAL_WARN( "package.xstor", "The stream become invalid during copiing!" );
         throw uno::RuntimeException();
@@ -2406,9 +2365,7 @@ void SAL_CALL OWriteStream::dispose()
             }
             catch( const uno::Exception& rException )
             {
-                m_pImpl->AddLog( rException.Message );
-                m_pImpl->AddLog( "Rethrow" );
-
+                SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
                 uno::Any aCaught( ::cppu::getCaughtException() );
                 throw lang::WrappedTargetRuntimeException("Can not commit/revert the storage!",
                                                 static_cast< OWeakObject* >( this ),
@@ -2532,15 +2489,12 @@ sal_Bool SAL_CALL OWriteStream::hasEncryptionData()
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( "Rethrow" );
-
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( "Problems on hasEncryptionData!",
                                   static_cast< ::cppu::OWeakObject* >( this ),
@@ -2570,8 +2524,7 @@ sal_Bool SAL_CALL OWriteStream::hasByID(  const OUString& sID )
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( "No Element" );
+        SAL_INFO("package.xstor", "No Element: " << rNoSuchElementException.Message);
     }
 
     return false;
@@ -3215,27 +3168,22 @@ void SAL_CALL OWriteStream::commit()
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( "Rethrow" );
-
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( "Problems on commit!",
                                   static_cast< ::cppu::OWeakObject* >( this ),
@@ -3275,27 +3223,22 @@ void SAL_CALL OWriteStream::revert()
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( "Rethrow" );
-
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( "Problems on revert!",
                                   static_cast< ::cppu::OWeakObject* >( this ),
diff --git a/package/source/xstor/owriteablestream.hxx b/package/source/xstor/owriteablestream.hxx
index fab951b32c69..a7cd759b6a72 100644
--- a/package/source/xstor/owriteablestream.hxx
+++ b/package/source/xstor/owriteablestream.hxx
@@ -38,7 +38,6 @@
 #include <com/sun/star/embed/XTransactionBroadcaster.hpp>
 #include <com/sun/star/container/XNameContainer.hpp>
 #include <com/sun/star/beans/StringPair.hpp>
-#include <com/sun/star/logging/XSimpleLogRing.hpp>
 
 #include <cppuhelper/weak.hxx>
 #include <cppuhelper/interfacecontainer.h>
@@ -91,7 +90,6 @@ struct OWriteStream_Impl : public MutexHolder
     bool                        m_bFlushed;      // sending the streams is coordinated by the root storage of the package
 
     css::uno::Reference< css::packages::XDataSinkEncrSupport > m_xPackageStream;
-    css::uno::Reference< css::logging::XSimpleLogRing >  m_xLogRing;
 
     css::uno::Reference< css::uno::XComponentContext > m_xContext;
 
@@ -156,8 +154,6 @@ public:
 
     void CleanCacheStream();
 
-    void AddLog( const OUString& aMessage );
-
     bool UsesCommonEncryption_Impl() { return m_bUseCommonEncryption; }
     bool HasTempFile_Impl() const { return ( m_aTempURL.getLength() != 0 ); }
     bool IsTransacted();
diff --git a/package/source/xstor/xstorage.cxx b/package/source/xstor/xstorage.cxx
index aa3007439d88..b451a625ecac 100644
--- a/package/source/xstor/xstorage.cxx
+++ b/package/source/xstor/xstorage.cxx
@@ -31,7 +31,6 @@
 #include <com/sun/star/packages/WrongPasswordException.hpp>
 #include <com/sun/star/ucb/XProgressHandler.hpp>
 #include <com/sun/star/io/TempFile.hpp>
-#include <com/sun/star/logging/DocumentIOLogRing.hpp>
 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
 #include <com/sun/star/container/XEnumerationAccess.hpp>
@@ -296,8 +295,7 @@ OStorage_Impl::~OStorage_Impl()
             }
             catch ( const uno::Exception& rException )
             {
-                AddLog( rException.Message );
-                AddLog( THROW_WHERE "Quiet exception" );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
             m_pAntiImpl = nullptr;
         }
@@ -312,8 +310,7 @@ OStorage_Impl::~OStorage_Impl()
                         pStorageIter->m_pPointer->InternalDispose( false );
                     } catch( const uno::Exception& rException )
                     {
-                        AddLog( rException.Message );
-                        AddLog( THROW_WHERE "Quiet exception" );
+                        SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
                     }
             }
 
@@ -365,33 +362,14 @@ OStorage_Impl::~OStorage_Impl()
                     m_xStream.clear();
                 }
             }
-            catch( const uno::Exception& rException )
+            catch (const uno::Exception& rException)
             {
-                AddLog( THROW_WHERE "Quiet exception" );
-                AddLog( rException.Message );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
         }
     }
 }
 
-void OStorage_Impl::AddLog( const OUString& aMessage )
-{
-    if ( !m_xLogRing.is() )
-    {
-        try
-        {
-            m_xLogRing = logging::DocumentIOLogRing::get(m_xContext);
-        }
-        catch( const uno::Exception& )
-        {
-            // No log
-        }
-    }
-
-    if ( m_xLogRing.is() )
-        m_xLogRing->logString( aMessage );
-}
-
 void OStorage_Impl::SetReadOnlyWrap( OStorage& aStorage )
 {
     // Weak reference is used inside the holder so the refcount must not be zero at this point
@@ -411,8 +389,7 @@ void OStorage_Impl::RemoveReadOnlyWrap( OStorage& aStorage )
                 pStorageIter->m_pPointer->InternalDispose( false );
             } catch( const uno::Exception& rException )
             {
-                AddLog( THROW_WHERE "Quiet exception" );
-                AddLog( rException.Message );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
 
             StorageHoldersType::iterator pIterToDelete( pStorageIter );
@@ -639,10 +616,7 @@ void OStorage_Impl::ReadContents()
         }
         catch( const container::NoSuchElementException& rNoSuchElementException )
         {
-            AddLog( rNoSuchElementException.Message );
-            AddLog( THROW_WHERE "NoSuchElement" );
-
-            SAL_WARN( "package.xstor", "hasMoreElements() implementation has problems!" );
+            SAL_WARN( "package.xstor", "hasMoreElements() implementation has problems! " << rNoSuchElementException.Message);
             break;
         }
     }
@@ -716,8 +690,7 @@ void OStorage_Impl::CopyToStorage( const uno::Reference< embed::XStorage >& xDes
             }
             catch( const packages::NoEncryptionException& rNoEncryptionException )
             {
-                AddLog( rNoEncryptionException.Message );
-                AddLog( THROW_WHERE "No Encryption" );
+                SAL_INFO("package.xstor", "No Encryption: " << rNoEncryptionException.Message);
             }
         }
     }
@@ -881,8 +854,7 @@ void OStorage_Impl::CopyStorageElement( SotElement_Impl* pElement,
             }
             catch( const packages::NoEncryptionException& rNoEncryptionException )
             {
-                AddLog( rNoEncryptionException.Message );
-                AddLog( THROW_WHERE "No Encryption" );
+                SAL_INFO("package.xstor", "No Encryption: " << rNoEncryptionException.Message);
             }
 
             if (bHasCommonEncryptionData && ::package::PackageEncryptionDatasEqual(pElement->m_xStream->GetCachedEncryptionData(), aCommonEncryptionData))
@@ -936,8 +908,7 @@ void OStorage_Impl::CopyStorageElement( SotElement_Impl* pElement,
             }
             catch( const packages::WrongPasswordException& rWrongPasswordException )
             {
-                AddLog( rWrongPasswordException.Message );
-                AddLog( THROW_WHERE "Handled exception" );
+                SAL_INFO("package.xstor", "Handled exception: " << rWrongPasswordException.Message);
 
                 // If the common storage password does not allow to open the stream
                 // it could be copied in raw way, the problem is that the StartKey should be the same
@@ -1224,8 +1195,7 @@ void OStorage_Impl::Commit()
                 throw aException;
             }
 
-            AddLog( aException.Message );
-            AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
             throw;
         }
     }
@@ -1853,8 +1823,7 @@ OStorage::~OStorage()
         }
         catch( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Handled exception" );
+            SAL_INFO("package.xstor", "Handled exception: " << rRuntimeException.Message);
         }
     }
 }
@@ -1899,8 +1868,7 @@ void SAL_CALL OStorage::InternalDispose( bool bNotifyImpl )
                             xTmp->dispose();
                         } catch( const uno::Exception& rException )
                         {
-                            m_pImpl->AddLog( rException.Message );
-                            m_pImpl->AddLog( THROW_WHERE "Quiet exception" );
+                            SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
                         }
                     }
                 }
@@ -2254,40 +2222,34 @@ void SAL_CALL OStorage::copyToStorage( const uno::Reference< embed::XStorage >&
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy storage!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2332,46 +2294,39 @@ uno::Reference< io::XStream > SAL_CALL OStorage::openStreamElement(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException(THROW_WHERE "Can't open stream element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2491,40 +2446,34 @@ uno::Reference< embed::XStorage > SAL_CALL OStorage::openStorageElement(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't open storage!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2559,46 +2508,39 @@ uno::Reference< io::XStream > SAL_CALL OStorage::cloneStreamElement( const OUStr
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't clone stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2629,40 +2571,34 @@ void SAL_CALL OStorage::copyLastCommitTo(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy last commit version!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2720,40 +2656,34 @@ void SAL_CALL OStorage::copyStorageElementLastCommitTo(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy last commit element version!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2784,34 +2714,29 @@ sal_Bool SAL_CALL OStorage::isStreamElement( const OUString& aElementName )
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can't detect whether it is a stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2847,34 +2772,29 @@ sal_Bool SAL_CALL OStorage::isStorageElement( const OUString& aElementName )
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "can't detect whether it is a storage",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2919,46 +2839,39 @@ void SAL_CALL OStorage::removeElement( const OUString& aElementName )
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't remove element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3006,52 +2919,44 @@ void SAL_CALL OStorage::renameElement( const OUString& aElementName, const OUStr
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't rename element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3099,52 +3004,44 @@ void SAL_CALL OStorage::copyElementTo(  const OUString& aElementName,
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3195,52 +3092,44 @@ void SAL_CALL OStorage::moveElementTo(  const OUString& aElementName,
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't move element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3290,52 +3179,44 @@ uno::Reference< io::XStream > SAL_CALL OStorage::openEncryptedStream(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( rNoEncryptionException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoEncryptionException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't open encrypted stream stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3376,52 +3257,44 @@ uno::Reference< io::XStream > SAL_CALL OStorage::cloneEncryptedStream(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( rNoEncryptionException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoEncryptionException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't clone encrypted stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3479,46 +3352,39 @@ uno::Reference< io::XInputStream > SAL_CALL OStorage::getPlainRawStreamElement(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't get plain raw stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3581,52 +3447,44 @@ uno::Reference< io::XInputStream > SAL_CALL OStorage::getRawEncrStreamElement(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( rNoEncryptionException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoEncryptionException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't get raw stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3668,52 +3526,44 @@ void SAL_CALL OStorage::insertRawEncrStreamElement( const OUString& aStreamName,
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::NoRawFormatException& rNoRawFormatException )
     {
-        m_pImpl->AddLog( rNoRawFormatException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoRawFormatException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't insert raw stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3747,26 +3597,22 @@ void SAL_CALL OStorage::commit()
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Problems on commit!",
@@ -3815,26 +3661,22 @@ void SAL_CALL OStorage::revert()
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Problems on revert!",
@@ -3983,26 +3825,22 @@ uno::Any SAL_CALL OStorage::getByName( const OUString& aName )
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const lang::WrappedTargetException& rWrappedTargetException )
     {
-        m_pImpl->AddLog( rWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetException( THROW_WHERE "Can not open storage!",
@@ -4029,14 +3867,12 @@ uno::Sequence< OUString > SAL_CALL OStorage::getElementNames()
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch ( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open storage!",
@@ -4068,14 +3904,12 @@ sal_Bool SAL_CALL OStorage::hasByName( const OUString& aName )
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch ( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open storage!",
@@ -4116,14 +3950,12 @@ sal_Bool SAL_CALL OStorage::hasElements()
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open storage!",
@@ -4149,14 +3981,12 @@ void SAL_CALL OStorage::dispose()
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open storage!",
@@ -4223,14 +4053,12 @@ void SAL_CALL OStorage::removeEncryption()
         }
         catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4252,16 +4080,14 @@ void SAL_CALL OStorage::removeEncryption()
         }
         catch( const uno::RuntimeException& rRException )
         {
-            m_pImpl->AddLog( rRException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rRException.Message);
 
             SAL_WARN( "package.xstor", "The call must not fail, it is pretty simple!" );
             throw;
         }
         catch( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             SAL_WARN( "package.xstor", "The call must not fail, it is pretty simple!" );
             throw io::IOException( THROW_WHERE );
@@ -4295,14 +4121,12 @@ void SAL_CALL OStorage::setEncryptionData( const uno::Sequence< beans::NamedValu
         }
         catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4322,8 +4146,7 @@ void SAL_CALL OStorage::setEncryptionData( const uno::Sequence< beans::NamedValu
         }
         catch( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             throw io::IOException( THROW_WHERE );
         }
@@ -4363,14 +4186,12 @@ void SAL_CALL OStorage::setEncryptionAlgorithms( const uno::Sequence< beans::Nam
         }
         catch ( const uno::RuntimeException& aRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& aException )
         {
-            m_pImpl->AddLog( aException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4386,14 +4207,12 @@ void SAL_CALL OStorage::setEncryptionAlgorithms( const uno::Sequence< beans::Nam
         }
         catch ( const uno::RuntimeException& aRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aRuntimeException.Message);
             throw;
         }
         catch( const uno::Exception& aException )
         {
-            m_pImpl->AddLog( aException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4425,14 +4244,12 @@ uno::Sequence< beans::NamedValue > SAL_CALL OStorage::getEncryptionAlgorithms()
         }
         catch ( const uno::RuntimeException& aRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& aException )
         {
-            m_pImpl->AddLog( aException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4447,14 +4264,12 @@ uno::Sequence< beans::NamedValue > SAL_CALL OStorage::getEncryptionAlgorithms()
         }
         catch ( const uno::RuntimeException& aRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aRuntimeException.Message);
             throw;
         }
         catch( const uno::Exception& aException )
         {
-            m_pImpl->AddLog( aException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4603,14 +4418,12 @@ uno::Any SAL_CALL OStorage::getPropertyValue( const OUString& aPropertyName )
         }
         catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetException(
@@ -4662,14 +4475,12 @@ uno::Any SAL_CALL OStorage::getPropertyValue( const OUString& aPropertyName )
             }
             catch ( const uno::RuntimeException& rRuntimeException )
             {
-                m_pImpl->AddLog( rRuntimeException.Message );
-                m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+                SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
                 throw;
             }
             catch ( const uno::Exception& rException )
             {
-                m_pImpl->AddLog( rException.Message );
-                m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+                SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
                 uno::Any aCaught( ::cppu::getCaughtException() );
                 throw lang::WrappedTargetException( THROW_WHERE "Can not open package!",
@@ -4766,8 +4577,7 @@ sal_Bool SAL_CALL OStorage::hasByID(  const OUString& sID )
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Quiet exception" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
     }
 
     return false;
@@ -5154,46 +4964,39 @@ void SAL_CALL OStorage::insertStreamElementDirect(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't insert stream directly!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5239,52 +5042,44 @@ void SAL_CALL OStorage::copyElementDirectlyTo(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy element direcly!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5313,40 +5108,34 @@ void SAL_CALL OStorage::writeAndAttachToStream( const uno::Reference< io::XStrea
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't write and attach to stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5389,40 +5178,34 @@ void SAL_CALL OStorage::attachToURL( const OUString& sURL,
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't attach to URL!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5466,58 +5249,49 @@ uno::Any SAL_CALL OStorage::getElementPropertyValue( const OUString& aElementNam
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const beans::UnknownPropertyException& rUnknownPropertyException )
     {
-        m_pImpl->AddLog( rUnknownPropertyException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rUnknownPropertyException.Message);
         throw;
     }
     catch( const beans::PropertyVetoException& rPropertyVetoException )
     {
-        m_pImpl->AddLog( rPropertyVetoException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rPropertyVetoException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't get element property!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5554,46 +5328,39 @@ void SAL_CALL OStorage::copyStreamElementData( const OUString& aStreamName, cons
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy stream data!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
diff --git a/package/source/xstor/xstorage.hxx b/package/source/xstor/xstorage.hxx
index 568caf3b90c2..4fb4ed0900c6 100644
--- a/package/source/xstor/xstorage.hxx
+++ b/package/source/xstor/xstorage.hxx
@@ -42,7 +42,6 @@
 #include <com/sun/star/lang/XTypeProvider.hpp>
 #include <com/sun/star/lang/XComponent.hpp>
 #include <com/sun/star/packages/NoEncryptionException.hpp>
-#include <com/sun/star/logging/XSimpleLogRing.hpp>
 
 #include <cppuhelper/weak.hxx>
 #include <cppuhelper/weakref.hxx>
@@ -142,7 +141,6 @@ struct OStorage_Impl
     SotElementList_Impl                         m_aDeletedList;
 
     css::uno::Reference< css::container::XNameContainer > m_xPackageFolder;
-    css::uno::Reference< css::logging::XSimpleLogRing >  m_xLogRing;
 
     css::uno::Reference< css::lang::XSingleServiceFactory > m_xPackage;
     css::uno::Reference< css::uno::XComponentContext >  m_xContext;
@@ -198,8 +196,6 @@ struct OStorage_Impl
 
     ~OStorage_Impl();
 
-    void AddLog( const OUString& aMessage );
-
     void SetReadOnlyWrap( OStorage& aStorage );
     void RemoveReadOnlyWrap( OStorage& aStorage );
 
diff --git a/sc/source/core/data/bcaslot.cxx b/sc/source/core/data/bcaslot.cxx
index 12ad9339a04d..e4cf53641c40 100644
--- a/sc/source/core/data/bcaslot.cxx
+++ b/sc/source/core/data/bcaslot.cxx
@@ -153,7 +153,7 @@ ScDocument::HardRecalcState ScBroadcastAreaSlot::CheckHardRecalcStateCondition()
             OSL_ENSURE( pShell, "Missing DocShell :-/" );
 
             if ( pShell )
-                pShell->SetError( SCWARN_CORE_HARD_RECALC, OSL_LOG_PREFIX );
+                pShell->SetError(SCWARN_CORE_HARD_RECALC);
 
             pDoc->SetAutoCalc( false );
             eState = ScDocument::HARDRECALCSTATE_ETERNAL;
diff --git a/sc/source/filter/excel/expop2.cxx b/sc/source/filter/excel/expop2.cxx
index 289ffb78fc62..e2fdfecf1a0a 100644
--- a/sc/source/filter/excel/expop2.cxx
+++ b/sc/source/filter/excel/expop2.cxx
@@ -106,7 +106,7 @@ FltError ExportBiff5::Write()
         SvxImportMSVBasic aBasicImport( *pDocShell, *xRootStrg );
         const ErrCode nErr = aBasicImport.SaveOrDelMSVBAStorage( true, EXC_STORAGE_VBA_PROJECT );
         if( nErr != ERRCODE_NONE )
-            pDocShell->SetError( nErr, OSL_LOG_PREFIX );
+            pDocShell->SetError(nErr);
     }
 
     pExcDoc->ReadDoc();         // ScDoc -> ExcDoc
diff --git a/sc/source/ui/docshell/docsh.cxx b/sc/source/ui/docshell/docsh.cxx
index 3fc6d41bd1cb..226032910265 100644
--- a/sc/source/ui/docshell/docsh.cxx
+++ b/sc/source/ui/docshell/docsh.cxx
@@ -456,7 +456,7 @@ bool ScDocShell::LoadXML( SfxMedium* pLoadMedium, const css::uno::Reference< css
         bRet = aImport.Import(ImportFlags::All, nError);
 
     if ( nError )
-        pLoadMedium->SetError( nError, OSL_LOG_PREFIX );
+        pLoadMedium->SetError(nError);
 
     processDataStream(*this, aImport.GetImportPostProcessData());
 
@@ -615,10 +615,10 @@ bool ScDocShell::Load( SfxMedium& rMedium )
     }
 
     if (!bRet && !rMedium.GetError())
-        rMedium.SetError( SVSTREAM_FILEFORMAT_ERROR, OSL_LOG_PREFIX );
+        rMedium.SetError(SVSTREAM_FILEFORMAT_ERROR);
 
     if (rMedium.GetError())
-        SetError( rMedium.GetError(), OSL_LOG_PREFIX );
+        SetError(rMedium.GetError());
 
     InitItems();
     CalcOutputFactor();
@@ -941,7 +941,7 @@ void ScDocShell::Notify( SfxBroadcaster&, const SfxHint& rHint )
                         }
 
                         if ( !bSuccess )
-                            SetError( ERRCODE_IO_ABORT, OSL_LOG_PREFIX ); // this error code will produce no error message, but will break the further saving process
+                            SetError(ERRCODE_IO_ABORT); // this error code will produce no error message, but will break the further saving process
                     }
 #endif
 
@@ -958,7 +958,7 @@ void ScDocShell::Notify( SfxBroadcaster&, const SfxHint& rHint )
 
                         if( RET_NO == aBox->Execute())
                         {
-                            SetError( ERRCODE_IO_ABORT, OSL_LOG_PREFIX ); // this error code will produce no error message, but will break the further saving process
+                            SetError(ERRCODE_IO_ABORT); // this error code will produce no error message, but will break the further saving process
                         }
                     }
                     SAL_FALLTHROUGH;
@@ -1101,7 +1101,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
                 if (eError != eERR_OK)
                 {
                     if (!GetError())
-                        SetError(eError, OSL_LOG_PREFIX);
+                        SetError(eError);
                 }
                 else
                     bRet = true;
@@ -1130,7 +1130,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
             if (eError != eERR_OK)
             {
                 if (!GetError())
-                    SetError(eError, OSL_LOG_PREFIX);
+                    SetError(eError);
 
                 if( ( eError & ERRCODE_WARNING_MASK ) == ERRCODE_WARNING_MASK )
                     bRet = true;
@@ -1167,13 +1167,13 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
             if (eError == SCWARN_IMPORT_RANGE_OVERFLOW)
             {
                 if (!GetError())
-                    SetError(eError, OSL_LOG_PREFIX);
+                    SetError(eError);
                 bRet = true;
             }
             else if (eError != eERR_OK)
             {
                 if (!GetError())
-                    SetError(eError, OSL_LOG_PREFIX);
+                    SetError(eError);
             }
             else
                 bRet = true;
@@ -1255,7 +1255,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
             if (eError != eERR_OK)
             {
                 if (!GetError())
-                    SetError(eError, OSL_LOG_PREFIX);
+                    SetError(eError);
             }
             else if (!GetError() && (bOverflowRow || bOverflowCol || bOverflowCell))
             {
@@ -1263,7 +1263,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
                 FltError nWarn = (bOverflowRow ? SCWARN_IMPORT_ROW_OVERFLOW :
                         (bOverflowCol ? SCWARN_IMPORT_COLUMN_OVERFLOW :
                          SCWARN_IMPORT_CELL_OVERFLOW));
-                SetError( nWarn, OSL_LOG_PREFIX);
+                SetError(nWarn);
             }
             bSetColWidths = true;
             bSetSimpleTextColWidths = true;
@@ -1295,7 +1295,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
             if (eError != eERR_OK)
             {
                 if (!GetError())
-                    SetError(eError, OSL_LOG_PREFIX);
+                    SetError(eError);
                 bRet = ( eError == SCWARN_IMPORT_RANGE_OVERFLOW );
             }
             else
@@ -1333,7 +1333,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
                 if (eError != eERR_OK)
                 {
                     if (!GetError())
-                        SetError(eError, OSL_LOG_PREFIX);
+                        SetError(eError);
 
                     if( ( eError & ERRCODE_WARNING_MASK ) == ERRCODE_WARNING_MASK )
                         bRet = true;
@@ -1369,7 +1369,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
             }
 
             if ( eError != eERR_OK && !GetError() )
-                SetError(eError, OSL_LOG_PREFIX);
+                SetError(eError);
             bSetColWidths = true;
             bSetSimpleTextColWidths = true;
             bSetRowHeights = true;
@@ -1380,7 +1380,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
             if (eError != eERR_OK)
             {
                 if (!GetError())
-                    SetError( eError, OSL_LOG_PREFIX );
+                    SetError(eError);
                 if( ( eError & ERRCODE_WARNING_MASK ) == ERRCODE_WARNING_MASK )
                     bRet = true;
             }
@@ -1406,7 +1406,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
                     if (eError != eERR_OK)
                     {
                         if (!GetError())
-                            SetError(eError, OSL_LOG_PREFIX);
+                            SetError(eError);
 
                         if( ( eError & ERRCODE_WARNING_MASK ) == ERRCODE_WARNING_MASK )
                             bRet = true;
@@ -1426,7 +1426,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
             }
 
             if ( eError != eERR_OK && !GetError() )
-                SetError(eError, OSL_LOG_PREFIX);
+                SetError(eError);
         }
         else if (aFltName == pFilterHtml || aFltName == pFilterHtmlWebQ)
         {
@@ -1458,7 +1458,7 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
                     if (eError != eERR_OK)
                     {
                         if (!GetError())
-                            SetError(eError, OSL_LOG_PREFIX);
+                            SetError(eError);
 
                         if( ( eError & ERRCODE_WARNING_MASK ) == ERRCODE_WARNING_MASK )
                             bRet = true;
@@ -1477,12 +1477,12 @@ bool ScDocShell::ConvertFrom( SfxMedium& rMedium )
             }
 
             if ( eError != eERR_OK && !GetError() )
-                SetError(eError, OSL_LOG_PREFIX);
+                SetError(eError);
         }
         else
         {
             if (!GetError())
-                SetError(SCERR_IMPORT_NI, OSL_LOG_PREFIX);
+                SetError(SCERR_IMPORT_NI);
         }
 
         if (!bCalc3)
@@ -2289,7 +2289,7 @@ bool ScDocShell::ConvertTo( SfxMedium &rMed )
             FltError eError = ScFormatFilter::Get().ScExportExcel5( rMed, &aDocument, eFormat, RTL_TEXTENCODING_MS_1252 );
 
             if( eError && !GetError() )
-                SetError( eError, OSL_LOG_PREFIX );
+                SetError(eError);
 
             // don't return false for warnings
             bRet = ((eError & ERRCODE_WARNING_MASK) == ERRCODE_WARNING_MASK) || (eError == eERR_OK);
@@ -2297,7 +2297,7 @@ bool ScDocShell::ConvertTo( SfxMedium &rMed )
         else
         {
             // export aborted, i.e. "Save without password" warning
-            SetError( ERRCODE_ABORT, OSL_LOG_PREFIX );
+            SetError(ERRCODE_ABORT);
         }
     }
     else if (aFltName == pFilterAscii)
@@ -2330,7 +2330,7 @@ bool ScDocShell::ConvertTo( SfxMedium &rMed )
 
             if (aDocument.GetTableCount() > 1)
                 if (!rMed.GetError())
-                    rMed.SetError(SCWARN_EXPORT_ASCII, OSL_LOG_PREFIX);
+                    rMed.SetError(SCWARN_EXPORT_ASCII);
         }
     }
     else if (aFltName == pFilterDBase)
@@ -2371,7 +2371,7 @@ bool ScDocShell::ConvertTo( SfxMedium &rMed )
         if ( eError != eERR_OK )
         {
             if (!GetError())
-                SetError(eError, OSL_LOG_PREFIX);
+                SetError(eError);
             if ( bHasMemo && IsDocument( aTmpFile ) )
                 KillFile( aTmpFile );
         }
@@ -2391,7 +2391,7 @@ bool ScDocShell::ConvertTo( SfxMedium &rMed )
                 {
                     KillFile( aTmpFile );
                     if ( !GetError() )
-                        SetError( SCERR_EXPORT_DATA, OSL_LOG_PREFIX );
+                        SetError(SCERR_EXPORT_DATA);
                 }
             }
         }
@@ -2425,7 +2425,7 @@ bool ScDocShell::ConvertTo( SfxMedium &rMed )
 
             if (aDocument.GetTableCount() > 1)
                 if (!rMed.GetError())
-                    rMed.SetError(SCWARN_EXPORT_ASCII, OSL_LOG_PREFIX);
+                    rMed.SetError(SCWARN_EXPORT_ASCII);
         }
     }
     else if (aFltName == pFilterSylk)
@@ -2467,14 +2467,14 @@ bool ScDocShell::ConvertTo( SfxMedium &rMed )
                 SetError(*new StringErrorInfo(
                     SCWARN_EXPORT_NONCONVERTIBLE_CHARS,
                     aImExport.GetNonConvertibleChars(),
-                    ErrorHandlerFlags::ButtonsOk | ErrorHandlerFlags::MessageInfo), OSL_LOG_PREFIX);
+                    ErrorHandlerFlags::ButtonsOk | ErrorHandlerFlags::MessageInfo));
             }
         }
     }
     else
     {
         if (GetError())
-            SetError(SCERR_IMPORT_NI, OSL_LOG_PREFIX);
+            SetError(SCERR_IMPORT_NI);
     }
     return bRet;
 }
diff --git a/sd/source/filter/sdpptwrp.cxx b/sd/source/filter/sdpptwrp.cxx
index cec616602373..ef9b8fe607eb 100644
--- a/sd/source/filter/sdpptwrp.cxx
+++ b/sd/source/filter/sdpptwrp.cxx
@@ -94,7 +94,7 @@ bool SdPPTFilter::Import()
             pDocStream->SetCryptMaskKey(pStorage->GetKey());
 
             if ( pStorage->IsStream( "EncryptedSummary" ) )
-                mrMedium.SetError( ERRCODE_SVX_READ_FILTER_PPOINT, OSL_LOG_PREFIX );
+                mrMedium.SetError(ERRCODE_SVX_READ_FILTER_PPOINT);
             else
             {
 #ifndef DISABLE_DYNLOADING
@@ -106,14 +106,14 @@ bool SdPPTFilter::Import()
                         bRet = PPTImport( &mrDocument, *pDocStream, *pStorage, mrMedium );
 
                     if ( !bRet )
-                        mrMedium.SetError( SVSTREAM_WRONGVERSION, OSL_LOG_PREFIX );
+                        mrMedium.SetError(SVSTREAM_WRONGVERSION);
                     pLibrary->release(); //TODO: let it get unloaded?
                     delete pLibrary;
                 }
 #else
                 bRet = ImportPPT( &mrDocument, *pDocStream, *pStorage, mrMedium );
                 if ( !bRet )
-                    mrMedium.SetError( SVSTREAM_WRONGVERSION, OSL_LOG_PREFIX );
+                    mrMedium.SetError(SVSTREAM_WRONGVERSION);
 #endif
             }
 
diff --git a/sd/source/ui/docshell/docshel4.cxx b/sd/source/ui/docshell/docshel4.cxx
index 0ee9859922cd..d1e464fa38d6 100644
--- a/sd/source/ui/docshell/docshel4.cxx
+++ b/sd/source/ui/docshell/docshel4.cxx
@@ -332,12 +332,12 @@ bool DrawDocShell::Load( SfxMedium& rMedium )
     else
     {
         if( nError == ERRCODE_IO_BROKENPACKAGE )
-            SetError( ERRCODE_IO_BROKENPACKAGE, OSL_LOG_PREFIX );
+            SetError(ERRCODE_IO_BROKENPACKAGE);
 
         // TODO/LATER: correct error handling?!
-        //pStore->SetError( SVSTREAM_WRONGVERSION, OUString( OSL_LOG_PREFIX ) );
+        //pStore->SetError(SVSTREAM_WRONGVERSION);
         else
-            SetError( ERRCODE_ABORT, OSL_LOG_PREFIX );
+            SetError(ERRCODE_ABORT);
     }
 
     // tell SFX to change viewshell when in preview mode
@@ -592,7 +592,7 @@ bool DrawDocShell::SaveAs( SfxMedium& rMedium )
         bRet = SdXMLFilter( rMedium, *this, SDXMLMODE_Normal, SotStorage::GetVersion( rMedium.GetStorage() ) ).Export();
 
     if( GetError() == ERRCODE_NONE )
-        SetError( nVBWarning, OSL_LOG_PREFIX );
+        SetError(nVBWarning);
 
     return bRet;
 }
diff --git a/sfx2/source/doc/docfile.cxx b/sfx2/source/doc/docfile.cxx
index 063fbf412f73..52384b439dd4 100644
--- a/sfx2/source/doc/docfile.cxx
+++ b/sfx2/source/doc/docfile.cxx
@@ -61,8 +61,6 @@
 #include <com/sun/star/ucb/TransferInfo.hpp>
 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
 #include <com/sun/star/ucb/OpenMode.hpp>
-#include <com/sun/star/logging/DocumentIOLogRing.hpp>
-#include <com/sun/star/logging/XSimpleLogRing.hpp>
 #include <com/sun/star/beans/PropertyValue.hpp>
 #include <com/sun/star/security/DocumentSignatureInformation.hpp>
 #include <com/sun/star/security/DocumentDigitalSignatures.hpp>
@@ -221,7 +219,6 @@ public:
     uno::Reference<io::XStream> xStream;
     uno::Reference<io::XStream> m_xLockingStream;
     uno::Reference<task::XInteractionHandler> xInteraction;
-    uno::Reference<logging::XSimpleLogRing> m_xLogRing;
 
     sal_uInt32                  nLastStorageError;
 
@@ -300,39 +297,16 @@ void SfxMedium::ResetError()
         pImpl->m_pOutStream->ResetError();
 }
 
-
 sal_uInt32 SfxMedium::GetLastStorageCreationState()
 {
     return pImpl->nLastStorageError;
 }
 
-
-void SfxMedium::AddLog( const OUString& aMessage )
-{
-    if ( !pImpl->m_xLogRing.is() )
-    {
-        try
-        {
-            Reference<XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
-            pImpl->m_xLogRing.set( logging::DocumentIOLogRing::get(xContext) );
-        }
-        catch( const uno::Exception& )
-        {}
-    }
-
-    if ( pImpl->m_xLogRing.is() )
-        pImpl->m_xLogRing->logString( aMessage );
-}
-
-
-void SfxMedium::SetError( sal_uInt32 nError, const OUString& aLogMessage )
+void SfxMedium::SetError(sal_uInt32 nError)
 {
     pImpl->m_eError = nError;
-    if ( pImpl->m_eError != ERRCODE_NONE && !aLogMessage.isEmpty() )
-        AddLog( aLogMessage );
 }
 
-
 sal_uInt32 SfxMedium::GetErrorCode() const
 {
     sal_uInt32 lError = pImpl->m_eError;
@@ -343,7 +317,6 @@ sal_uInt32 SfxMedium::GetErrorCode() const
     return lError;
 }
 
-
 void SfxMedium::CheckFileDate( const util::DateTime& aInitDate )
 {
     GetInitFileDate( true );
@@ -372,7 +345,7 @@ void SfxMedium::CheckFileDate( const util::DateTime& aInitDate )
                 ::rtl::Reference< ::ucbhelper::InteractionContinuation > xSelected = xInteractionRequestImpl->getSelection();
                 if ( uno::Reference< task::XInteractionAbort >( xSelected.get(), uno::UNO_QUERY ).is() )
                 {
-                    SetError( ERRCODE_ABORT, OSL_LOG_PREFIX );
+                    SetError(ERRCODE_ABORT);
                 }
             }
             catch ( const uno::Exception& )
@@ -760,7 +733,7 @@ void SfxMedium::StorageBackup_Impl()
     {
         DoInternalBackup_Impl( aOriginalContent );
         if( pImpl->m_aBackupURL.isEmpty() )
-            SetError( ERRCODE_SFX_CANTCREATEBACKUP, OSL_LOG_PREFIX );
+            SetError(ERRCODE_SFX_CANTCREATEBACKUP);
     }
 }
 
@@ -819,7 +792,7 @@ void SfxMedium::SetEncryptionDataToStorage_Impl()
             {
                 SAL_WARN( "sfx.doc", "It must be possible to set a common password for the storage" );
                 // TODO/LATER: set the error code in case of problem
-                // SetError( ERRCODE_IO_GENERAL, OUString( OSL_LOG_PREFIX  ) );
+                // SetError(ERRCODE_IO_GENERAL);
             }
         }
     }
@@ -896,7 +869,7 @@ SfxMedium::ShowLockResult SfxMedium::ShowLockedDocumentDialog( const LockFileEnt
         ::rtl::Reference< ::ucbhelper::InteractionContinuation > xSelected = xInteractionRequestImpl->getSelection();
         if ( uno::Reference< task::XInteractionAbort >( xSelected.get(), uno::UNO_QUERY ).is() )
         {
-            SetError( ERRCODE_ABORT, OSL_LOG_PREFIX );
+            SetError(ERRCODE_ABORT);
         }
         else if ( uno::Reference< task::XInteractionDisapprove >( xSelected.get(), uno::UNO_QUERY ).is() )
         {
@@ -935,7 +908,7 @@ SfxMedium::ShowLockResult SfxMedium::ShowLockedDocumentDialog( const LockFileEnt
             GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
         }
         else
-            SetError( ERRCODE_IO_ACCESSDENIED, OSL_LOG_PREFIX );
+            SetError(ERRCODE_IO_ACCESSDENIED);
 
     }
 
@@ -1068,7 +1041,7 @@ void SfxMedium::LockOrigFileOnDemand( bool bLoading, bool bNoUI )
                 const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet, SID_DOC_READONLY, false);
 
                 if ( !bLoading || (pReadOnlyItem && !pReadOnlyItem->GetValue()) )
-                    SetError( ERRCODE_IO_ACCESSDENIED, OSL_LOG_PREFIX );
+                    SetError(ERRCODE_IO_ACCESSDENIED);
                 else
                     GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
             }
@@ -1286,7 +1259,7 @@ void SfxMedium::LockOrigFileOnDemand( bool bLoading, bool bNoUI )
             const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet, SID_DOC_READONLY, false);
 
             if ( !bLoading || (pReadOnlyItem && !pReadOnlyItem->GetValue()) )
-                SetError( ERRCODE_IO_ACCESSDENIED, OSL_LOG_PREFIX );
+                SetError(ERRCODE_IO_ACCESSDENIED);
             else
                 GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
         }
@@ -1638,12 +1611,12 @@ bool SfxMedium::StorageCommit_Impl()
                     }
 
                     if (!GetError())
-                        SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                        SetError(ERRCODE_IO_GENERAL);
                 }
                 catch ( const uno::Exception& )
                 {
                     //TODO/LATER: improve error handling
-                    SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                    SetError(ERRCODE_IO_GENERAL);
                 }
             }
         }
@@ -1914,7 +1887,7 @@ void SfxMedium::Transfer_Impl()
             else
             {
                 SAL_WARN( "sfx.doc", "Illegal Output stream parameter!" );
-                SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                SetError(ERRCODE_IO_GENERAL);
             }
 
             // free the reference
@@ -2448,7 +2421,7 @@ void SfxMedium::GetMedium_Impl()
 
         //TODO/MBA: ErrorHandling - how to transport error from MediaDescriptor
         if ( !GetError() && !pImpl->xStream.is() && !pImpl->xInputStream.is() )
-            SetError( ERRCODE_IO_ACCESSDENIED, OSL_LOG_PREFIX );
+            SetError(ERRCODE_IO_ACCESSDENIED);
 
         if ( !GetError() )
         {
@@ -3365,7 +3338,7 @@ void SfxMedium::CreateTempFile( bool bReplace )
     OUString aTmpURL = pImpl->pTempFile->GetURL();
     if ( pImpl->m_aName.isEmpty() || aTmpURL.isEmpty() )
     {
-        SetError( ERRCODE_IO_CANTWRITE, OSL_LOG_PREFIX );
+        SetError(ERRCODE_IO_CANTWRITE);
         return;
     }
 
@@ -3443,7 +3416,7 @@ void SfxMedium::CreateTempFile( bool bReplace )
 
         if ( !bTransferSuccess )
         {
-            SetError( ERRCODE_IO_CANTWRITE, OSL_LOG_PREFIX );
+            SetError(ERRCODE_IO_CANTWRITE);
             return;
         }
     }
@@ -3463,7 +3436,7 @@ void SfxMedium::CreateTempFileNoCopy()
     pImpl->m_aName = pImpl->pTempFile->GetFileName();
     if ( pImpl->m_aName.isEmpty() )
     {
-        SetError( ERRCODE_IO_CANTWRITE, OSL_LOG_PREFIX );
+        SetError(ERRCODE_IO_CANTWRITE);
         return;
     }
 
diff --git a/sfx2/source/doc/objmisc.cxx b/sfx2/source/doc/objmisc.cxx
index cfccb7d7fc41..95978350fb78 100644
--- a/sfx2/source/doc/objmisc.cxx
+++ b/sfx2/source/doc/objmisc.cxx
@@ -37,7 +37,6 @@
 #include <com/sun/star/document/XScriptInvocationContext.hpp>
 #include <com/sun/star/embed/EmbedStates.hpp>
 #include <com/sun/star/embed/XEmbedPersist.hpp>
-#include <com/sun/star/logging/DocumentIOLogRing.hpp>
 #include <com/sun/star/script/XTypeConverter.hpp>
 #include <com/sun/star/script/FinishEngineEvent.hpp>
 #include <com/sun/star/script/InterruptReason.hpp>
@@ -210,25 +209,19 @@ void SfxObjectShell::FlushDocInfo()
                  (delay > 0) || !url.isEmpty() );
 }
 
-
-void SfxObjectShell::SetError( sal_uInt32 lErr, const OUString& aLogMessage )
+void SfxObjectShell::SetError(sal_uInt32 lErr)
 {
-    if(pImpl->lErr==ERRCODE_NONE)
+    if (pImpl->lErr==ERRCODE_NONE)
     {
         pImpl->lErr=lErr;
-
-        if( lErr != ERRCODE_NONE && !aLogMessage.isEmpty() )
-            AddLog( aLogMessage );
     }
 }
 
-
 sal_uInt32 SfxObjectShell::GetError() const
 {
     return ERRCODE_TOERROR(GetErrorCode());
 }
 
-
 sal_uInt32 SfxObjectShell::GetErrorCode() const
 {
     sal_uInt32 lError=pImpl->lErr;
@@ -237,19 +230,14 @@ sal_uInt32 SfxObjectShell::GetErrorCode() const
     return lError;
 }
 
-
 void SfxObjectShell::ResetError()
 {
-    if( pImpl->lErr != ERRCODE_NONE )
-        AddLog( OSL_LOG_PREFIX "Resetting Error." );
-
     pImpl->lErr=0;
     SfxMedium * pMed = GetMedium();
     if( pMed )
         pMed->ResetError();
 }
 
-
 void SfxObjectShell::EnableSetModified( bool bEnable )
 {
     SAL_INFO_IF( bEnable == pImpl->m_bEnableSetModified, "sfx", "SFX_PERSIST: EnableSetModified 2x called with the same value" );
@@ -1242,7 +1230,7 @@ void SfxObjectShell::TemplateDisconnectionAfterLoad()
             }
             else
             {
-                SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                SetError(ERRCODE_IO_GENERAL);
             }
         }
         else
@@ -1848,89 +1836,6 @@ bool SfxObjectShell_Impl::hasTrustedScriptingSignature( bool bAllowUIToAddAuthor
     return bResult;
 }
 
-void SfxObjectShell::AddLog( const OUString& aMessage )
-{
-    if ( !pImpl->m_xLogRing.is() )
-    {
-        try
-        {
-            Reference<XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
-            pImpl->m_xLogRing.set( logging::DocumentIOLogRing::get(xContext) );
-        }
-        catch( uno::Exception& )
-        {}
-    }
-
-    if ( pImpl->m_xLogRing.is() )
-        pImpl->m_xLogRing->logString( aMessage );
-}
-
-namespace {
-
-void WriteStringInStream( const uno::Reference< io::XOutputStream >& xOutStream, const OUString& aString )
-{
-    if ( xOutStream.is() )
-    {
-        OString aStrLog = OUStringToOString( aString, RTL_TEXTENCODING_UTF8 );
-        uno::Sequence< sal_Int8 > aLogData( reinterpret_cast<const sal_Int8*>(aStrLog.getStr()), aStrLog.getLength() );
-        xOutStream->writeBytes( aLogData );
-
-        aLogData.realloc( 1 );
-        aLogData[0] = '\n';
-        xOutStream->writeBytes( aLogData );
-    }
-}
-
-}
-
-void SfxObjectShell::StoreLog()
-{
-    if ( !pImpl->m_xLogRing.is() )
-    {
-        try
-        {
-            Reference<XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
-            pImpl->m_xLogRing.set( logging::DocumentIOLogRing::get(xContext) );
-        }
-        catch( uno::Exception& )
-        {}
-    }
-
-    if ( pImpl->m_xLogRing.is() )
-    {
-        OUString aFileURL = ( "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}"  );
-
-        ::rtl::Bootstrap::expandMacros( aFileURL );
-
-        OUString aBuildID = ( "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("setup") ":buildid}"  );
-
-        ::rtl::Bootstrap::expandMacros( aBuildID );
-
-        if ( !aFileURL.isEmpty() )
-        {
-            aFileURL += "/user/temp/document_io_logring.txt";
-            try
-            {
-                uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
-                uno::Reference< ucb::XSimpleFileAccess3 > xSimpleFileAccess(ucb::SimpleFileAccess::create(xContext));
-                uno::Reference< io::XStream > xStream( xSimpleFileAccess->openFileReadWrite( aFileURL ), uno::UNO_SET_THROW );
-                uno::Reference< io::XOutputStream > xOutStream( xStream->getOutputStream(), uno::UNO_SET_THROW );
-                uno::Reference< io::XTruncate > xTruncate( xOutStream, uno::UNO_QUERY_THROW );
-                xTruncate->truncate();
-
-                if ( !aBuildID.isEmpty() )
-                    WriteStringInStream( xOutStream, aBuildID );
-
-                uno::Sequence< OUString > aLogSeq = pImpl->m_xLogRing->getCollectedLog();
-                for ( sal_Int32 nInd = 0; nInd < aLogSeq.getLength(); nInd++ )
-                    WriteStringInStream( xOutStream, aLogSeq[nInd] );
-            }
-            catch( uno::Exception& )
-            {}
-        }
-    }
-}
-
 bool SfxObjectShell::IsContinueImportOnFilterExceptions(const OUString& aErrMessage)
 {
     if (mbContinueImportOnFilterExceptions == undefined)
diff --git a/sfx2/source/doc/objstor.cxx b/sfx2/source/doc/objstor.cxx
index 72eeba95925b..2b1e18853400 100644
--- a/sfx2/source/doc/objstor.cxx
+++ b/sfx2/source/doc/objstor.cxx
@@ -253,7 +253,7 @@ bool SfxObjectShell::PutURLContentsToVersionStream_Impl(
     catch( uno::Exception& )
     {
         // TODO/LATER: handle the error depending on exception
-        SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+        SetError(ERRCODE_IO_GENERAL);
     }
 
     return bResult;
@@ -285,7 +285,7 @@ OUString SfxObjectShell::CreateTempCopyOfStorage_Impl( const uno::Reference< emb
             aTempURL.clear();
 
             // TODO/LATER: may need error code setting based on exception
-            SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+            SetError(ERRCODE_IO_GENERAL);
         }
     }
 
@@ -359,7 +359,7 @@ void SfxObjectShell::SetupStorage( const uno::Reference< embed::XStorage >& xSto
                 }
                 catch( uno::Exception& )
                 {
-                    const_cast<SfxObjectShell*>( this )->SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                    const_cast<SfxObjectShell*>( this )->SetError(ERRCODE_IO_GENERAL);
                 }
 
                 SvtSaveOptions::ODFDefaultVersion nDefVersion = SvtSaveOptions::ODFVER_012;
@@ -412,7 +412,7 @@ void SfxObjectShell::SetupStorage( const uno::Reference< embed::XStorage >& xSto
                 }
                 catch( uno::Exception& )
                 {
-                    const_cast<SfxObjectShell*>( this )->SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                    const_cast<SfxObjectShell*>( this )->SetError(ERRCODE_IO_GENERAL);
                 }
 
             }
@@ -450,7 +450,7 @@ bool SfxObjectShell::GeneralInit_Impl( const uno::Reference< embed::XStorage >&
             {
                 if ( bTypeMustBeSetAlready )
                 {
-                    SetError( ERRCODE_IO_BROKENPACKAGE, OSL_LOG_PREFIX );
+                    SetError(ERRCODE_IO_BROKENPACKAGE);
                     return false;
                 }
 
@@ -662,7 +662,7 @@ bool SfxObjectShell::DoLoad( SfxMedium *pMed )
     {
         sal_uInt32 nError = HandleFilter( pMedium, this );
         if ( nError != ERRCODE_NONE )
-            SetError( nError, OSL_LOG_PREFIX );
+            SetError(nError);
 
         if (pMedium->GetFilter()->GetFilterFlags() & SfxFilterFlags::STARTPRESENTATION)
             pSet->Put( SfxBoolItem( SID_DOC_STARTPRESENTATION, true) );
@@ -702,12 +702,12 @@ bool SfxObjectShell::DoLoad( SfxMedium *pMed )
                 }
 
                 if ( bWarnMediaTypeFallback || !xStorage->getElementNames().getLength() )
-                    SetError( ERRCODE_IO_BROKENPACKAGE, OSL_LOG_PREFIX );
+                    SetError(ERRCODE_IO_BROKENPACKAGE);
             }
             catch( uno::Exception& )
             {
                 // TODO/LATER: may need error code setting based on exception
-                SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                SetError(ERRCODE_IO_GENERAL);
             }
 
             // Load
@@ -724,11 +724,11 @@ bool SfxObjectShell::DoLoad( SfxMedium *pMed )
                         bHasName = true;
                 }
                 else
-                    SetError( ERRCODE_ABORT, OSL_LOG_PREFIX );
+                    SetError(ERRCODE_ABORT);
             }
         }
         else
-            SetError( pMed->GetLastStorageCreationState(), OSL_LOG_PREFIX );
+            SetError(pMed->GetLastStorageCreationState());
     }
     else if ( GetError() == ERRCODE_NONE && InitNew(nullptr) )
     {
@@ -1010,7 +1010,7 @@ bool SfxObjectShell::DoSave()
                 }
                 catch( uno::Exception& )
                 {
-                    SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                    SetError(ERRCODE_IO_GENERAL);
                 }
 
                 DBG_ASSERT( bOk, "The root storage must allow to set common password!\n" );
@@ -1050,7 +1050,7 @@ bool SfxObjectShell::DoSave()
                 }
                 catch( uno::Exception& )
                 {
-                    SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                    SetError(ERRCODE_IO_GENERAL);
                     bOk = false;
                 }
             }
@@ -1100,8 +1100,6 @@ bool SfxObjectShell::SaveTo_Impl
 
     UpdateDocInfoForSave();
 
-    AddLog( OSL_LOG_PREFIX "Begin" );
-
     ModifyBlocker_Impl aMod(this);
 
     std::shared_ptr<const SfxFilter> pFilter = rMedium.GetFilter();
@@ -1123,7 +1121,7 @@ bool SfxObjectShell::SaveTo_Impl
     // protected libraries exceed the size we can handler
     if ( bOwnTarget && !QuerySaveSizeExceededModules_Impl( rMedium.GetInteractionHandler() ) )
     {
-        SetError( ERRCODE_IO_ABORT, OSL_LOG_PREFIX );
+        SetError(ERRCODE_IO_ABORT);
         return false;
     }
 
@@ -1140,8 +1138,6 @@ bool SfxObjectShell::SaveTo_Impl
         || pImpl->nScriptingSignatureState == SignatureState::NOTVALIDATED
         || pImpl->nScriptingSignatureState == SignatureState::INVALID ) )
     {
-        AddLog( OSL_LOG_PREFIX "MacroSignaturePreserving" );
-
         // the checking of the library modified state iterates over the libraries, should be done only when required
         // currently the check is commented out since it is broken, we have to check the signature every time we save
         // TODO/LATER: let isAnyContainerModified() work!
@@ -1186,7 +1182,6 @@ bool SfxObjectShell::SaveTo_Impl
       && ::utl::UCBContentHelper::EqualURLs( pMedium->GetName(), rMedium.GetName() ) )
     {
         bStoreToSameLocation = true;
-        AddLog( OSL_LOG_PREFIX "Save" );
 
         if ( pMedium->DocNeedsFileDateCheck() )
             rMedium.CheckFileDate( pMedium->GetInitFileDate( false ) );
@@ -1194,7 +1189,7 @@ bool SfxObjectShell::SaveTo_Impl
         if ( bCopyTo && GetCreateMode() != SfxObjectCreateMode::EMBEDDED )
         {
             // export to the same location is forbidden
-            SetError( ERRCODE_IO_CANTWRITE, OSL_LOG_PREFIX );
+            SetError(ERRCODE_IO_CANTWRITE);
         }
         else
         {
@@ -1203,11 +1198,10 @@ bool SfxObjectShell::SaveTo_Impl
             const bool bDoBackup = SvtSaveOptions().IsBackup();
             if ( bDoBackup )
             {
-                AddLog( OSL_LOG_PREFIX "DoBackup" );
                 rMedium.DoBackup_Impl();
                 if ( rMedium.GetError() )
                 {
-                    SetError( rMedium.GetErrorCode(), OSL_LOG_PREFIX );
+                    SetError(rMedium.GetErrorCode());
                     rMedium.ResetError();
                 }
             }
@@ -1231,8 +1225,6 @@ bool SfxObjectShell::SaveTo_Impl
                     // if the last step is failed the stream should stay to be transacted and should be committed on any flush
                     // so we can forget the stream in any way and the next storage commit will flush it
 
-                AddLog( OSL_LOG_PREFIX "Save: Own to Own" );
-
                 bNeedsDisconnectionOnFail = DisconnectStorage_Impl(
                     *pMedium, rMedium );
                 if ( bNeedsDisconnectionOnFail
@@ -1254,8 +1246,6 @@ bool SfxObjectShell::SaveTo_Impl
                 // just disconnect the stream from the source format
                 // so that the target medium can use it
 
-                AddLog( OSL_LOG_PREFIX "Save: Alien to Alien" );
-
                 pMedium->CloseAndRelease();
                 rMedium.CloseAndRelease();
                 rMedium.CreateTempFileNoCopy();
@@ -1267,8 +1257,6 @@ bool SfxObjectShell::SaveTo_Impl
                 // format is an own one so just disconnect the source
                 // medium
 
-                AddLog( OSL_LOG_PREFIX "Save: Alien to Own" );
-
                 pMedium->CloseAndRelease();
                 rMedium.CloseAndRelease();
                 rMedium.GetOutputStorage();
@@ -1279,8 +1267,6 @@ bool SfxObjectShell::SaveTo_Impl
                 // an alien format, just connect the source to temporary
                 // storage
 
-                AddLog( OSL_LOG_PREFIX "Save: Own to Alien" );
-
                 bNeedsDisconnectionOnFail = DisconnectStorage_Impl(
                     *pMedium, rMedium );
                 if ( bNeedsDisconnectionOnFail
@@ -1301,8 +1287,6 @@ bool SfxObjectShell::SaveTo_Impl
         // but for now the framework has to be ready for it
         // TODO/LATER: let the medium be prepared for alien formats as well
 
-        AddLog( OSL_LOG_PREFIX "SaveAs/Export" );
-
         rMedium.CloseAndRelease();
         if ( bStorageBasedTarget )
         {
@@ -1317,8 +1301,6 @@ bool SfxObjectShell::SaveTo_Impl
         return false;
     }
 
-    AddLog( OSL_LOG_PREFIX "Locking" );
-
     rMedium.LockOrigFileOnDemand( false, false );
 
     if ( bStorageBasedTarget )
@@ -1366,14 +1348,12 @@ bool SfxObjectShell::SaveTo_Impl
     // TODO/LATER: get rid of bOk
     if (bOwnTarget && pFilter && !(pFilter->GetFilterFlags() & SfxFilterFlags::STARONEFILTER))
     {
-        AddLog( OSL_LOG_PREFIX "Storing in own format." );
         uno::Reference< embed::XStorage > xMedStorage = rMedium.GetStorage();
         if ( !xMedStorage.is() )
         {
             // no saving without storage, unlock UI and return
             Lock_Impl( this, false );
             pImpl->bForbidReload = bOldStat;
-            AddLog( OSL_LOG_PREFIX "Storing failed, still no error set." );
             return false;
         }
 
@@ -1390,7 +1370,7 @@ bool SfxObjectShell::SaveTo_Impl
             catch( uno::Exception& )
             {
                 SAL_WARN( "sfx.doc", "Setting of common encryption key failed!" );
-                SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+                SetError(ERRCODE_IO_GENERAL);
             }
         }
         else
@@ -1408,18 +1388,15 @@ bool SfxObjectShell::SaveTo_Impl
             if ( xMedStorage == GetStorage() )
             {
                 OSL_ENSURE( !pVersionItem, "This scenario is impossible currently!\n" );
-                AddLog( OSL_LOG_PREFIX "Should be impossible." );
                 // usual save procedure
                 bOk = Save();
             }
             else
             {
                 // save to target
-                AddLog( OSL_LOG_PREFIX "Save as own format." );
                 bOk = SaveAsOwnFormat( rMedium );
                 if ( bOk && pVersionItem )
                 {
-                    AddLog( OSL_LOG_PREFIX "pVersionItem != NULL" );
                     aTmpVersionURL = CreateTempCopyOfStorage_Impl( xMedStorage );
                     bOk =  !aTmpVersionURL.isEmpty();
                 }
@@ -1432,7 +1409,6 @@ bool SfxObjectShell::SaveTo_Impl
         {
             // store the thumbnail representation image
             // the thumbnail is not stored in case of encrypted document
-            AddLog( OSL_LOG_PREFIX "Thumbnail creation." );
             if ( !GenerateAndStoreThumbnail( bPasswdProvided,
                                             pFilter->IsOwnTemplateFormat(),
                                             xMedStorage ) )
@@ -1446,7 +1422,6 @@ bool SfxObjectShell::SaveTo_Impl
         {
             if ( pImpl->bIsSaving || pImpl->bPreserveVersions )
             {
-                AddLog( OSL_LOG_PREFIX "Preserve versions." );
                 try
                 {
                     Sequence < util::RevisionTag > aVersions = rMedium.GetVersionList();
@@ -1476,7 +1451,6 @@ bool SfxObjectShell::SaveTo_Impl
                 }
                 catch( uno::Exception& )
                 {
-                    AddLog( OSL_LOG_PREFIX "Preserve versions has failed." );
                     SAL_WARN( "sfx.doc", "Couldn't copy versions!" );
                     bOk = false;
                     // TODO/LATER: a specific error could be set
@@ -1527,7 +1501,6 @@ bool SfxObjectShell::SaveTo_Impl
     }
     else
     {
-        AddLog( OSL_LOG_PREFIX "Storing in alien format." );
         // it's a "SaveAs" in an alien format
         if ( rMedium.GetFilter() && ( rMedium.GetFilter()->GetFilterFlags() & SfxFilterFlags::STARONEFILTER ) )
             bOk = ExportTo( rMedium );
@@ -1556,8 +1529,6 @@ bool SfxObjectShell::SaveTo_Impl
         uno::Reference< security::XDocumentDigitalSignatures > xDDSigns;
         if ( bOk && bTryToPreserveScriptSignature )
         {
-            AddLog( OSL_LOG_PREFIX "Copying scripting signature." );
-
             // if the scripting code was not changed and it is signed the signature should be preserved
             // unfortunately at this point we have only information whether the basic code has changed or not
             // so the only way is to check the signature if the basic was not changed
@@ -1640,8 +1611,6 @@ bool SfxObjectShell::SaveTo_Impl
             rMedium.CloseZipStorage_Impl();
         }
 
-        AddLog( OSL_LOG_PREFIX "Medium commit." );
-
         OUString sName( rMedium.GetName( ) );
         bOk = rMedium.Commit();
         OUString sNewName( rMedium.GetName( ) );
@@ -1651,8 +1620,6 @@ bool SfxObjectShell::SaveTo_Impl
 
         if ( bOk )
         {
-            AddLog( OSL_LOG_PREFIX "Storing is successful." );
-
             // if the target medium is an alien format and the "old" medium was an own format and the "old" medium
             // has a name, the object storage must be exchanged, because now we need a new temporary storage
             // as object storage
@@ -1672,7 +1639,7 @@ bool SfxObjectShell::SaveTo_Impl
                     // copy storage of old medium to new temporary storage and take this over
                     if( !ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) )
                     {
-                        AddLog( OSL_LOG_PREFIX "Process after storing has failed." );
+                        SAL_WARN( "sfx.doc", "Process after storing has failed." );
                         bOk = false;
                     }
                 }
@@ -1680,7 +1647,7 @@ bool SfxObjectShell::SaveTo_Impl
         }
         else
         {
-            AddLog( OSL_LOG_PREFIX "Storing has failed." );
+            SAL_WARN( "sfx.doc", "Storing has failed." );
 
             // in case the document storage was connected to backup temporarely it must be disconnected now
             if ( bNeedsDisconnectionOnFail )
@@ -1861,7 +1828,7 @@ bool SfxObjectShell::ConnectTmpStorage_Impl(
         if ( !bResult )
         {
             // TODO/LATER: may need error code setting based on exception
-            SetError( ERRCODE_IO_GENERAL, OSL_LOG_PREFIX );
+            SetError(ERRCODE_IO_GENERAL);
         }
     }
     else if (!GetMedium()->GetFilter()->IsOwnFormat())
@@ -1917,7 +1884,7 @@ bool SfxObjectShell::DoSaveAs( SfxMedium& rMedium )
 {
     // here only root storages are included, which are stored via temp file
     rMedium.CreateTempFileNoCopy();
-    SetError(rMedium.GetErrorCode(), OSL_LOG_PREFIX );
+    SetError(rMedium.GetErrorCode());
     if ( GetError() )
         return false;
 
@@ -1927,7 +1894,7 @@ bool SfxObjectShell::DoSaveAs( SfxMedium& rMedium )
 
     bool bRet = SaveTo_Impl( rMedium, nullptr );
     if ( !bRet )
-        SetError(rMedium.GetErrorCode(), OSL_LOG_PREFIX );
+        SetError(rMedium.GetErrorCode());
     return bRet;
 }
 
@@ -2281,7 +2248,7 @@ bool SfxObjectShell::ImportFrom(SfxMedium& rMedium,
         }
         catch (const packages::zip::ZipIOException&)
         {
-            SetError( ERRCODE_IO_BROKENPACKAGE, "Badness in the underlying package format." );
+            SetError(ERRCODE_IO_BROKENPACKAGE);
         }
         catch (const lang::WrappedTargetRuntimeException& rWrapped)
         {
@@ -2289,7 +2256,7 @@ bool SfxObjectShell::ImportFrom(SfxMedium& rMedium,
             if (rWrapped.TargetException >>= e)
             {
                 SetError(*new StringErrorInfo(ERRCODE_SFX_FORMAT_ROWCOL,
-                    e.Message, ErrorHandlerFlags::ButtonsOk | ErrorHandlerFlags::MessageError ), "");
+                    e.Message, ErrorHandlerFlags::ButtonsOk | ErrorHandlerFlags::MessageError ));
             }
         }
         catch (const std::exception& e)
@@ -2297,7 +2264,7 @@ bool SfxObjectShell::ImportFrom(SfxMedium& rMedium,
             const char *msg = e.what();
             OUString sError(msg, strlen(msg), RTL_TEXTENCODING_ASCII_US);
             SetError(*new StringErrorInfo(ERRCODE_SFX_DOLOADFAILED,
-                sError, ErrorHandlerFlags::ButtonsOk | ErrorHandlerFlags::MessageError), "");
+                sError, ErrorHandlerFlags::ButtonsOk | ErrorHandlerFlags::MessageError));
         }
         catch (...)
         {
@@ -2513,7 +2480,7 @@ bool SfxObjectShell::DoSave_Impl( const SfxItemSet* pArgs )
     pMediumTmp->SetLongName( pRetrMedium->GetLongName() );
     if ( pMediumTmp->GetErrorCode() != ERRCODE_NONE )
     {
-        SetError( pMediumTmp->GetError(), OSL_LOG_PREFIX );
+        SetError(pMediumTmp->GetError());
         delete pMediumTmp;
         return false;
     }
@@ -2539,7 +2506,7 @@ bool SfxObjectShell::DoSave_Impl( const SfxItemSet* pArgs )
             pMediumTmp->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL );
         }
 
-        SetError(pMediumTmp->GetErrorCode(), OSL_LOG_PREFIX );
+        SetError(pMediumTmp->GetErrorCode());
 
         bool bOpen( false );
         bOpen = DoSaveCompleted( pMediumTmp );
@@ -2550,7 +2517,7 @@ bool SfxObjectShell::DoSave_Impl( const SfxItemSet* pArgs )
     else
     {
         // transfer error code from medium to objectshell
-        SetError( pMediumTmp->GetError(), OSL_LOG_PREFIX );
+        SetError(pMediumTmp->GetError());
 
         // reconnect to object storage
         DoSaveCompleted();
@@ -2573,11 +2540,10 @@ bool SfxObjectShell::Save_Impl( const SfxItemSet* pSet )
 {
     if ( IsReadOnly() )
     {
-        SetError( ERRCODE_SFX_DOCUMENTREADONLY, OSL_LOG_PREFIX );
+        SetError(ERRCODE_SFX_DOCUMENTREADONLY);
         return false;
     }
 
-
     pImpl->bIsSaving = true;
     bool bSaved = false;
     const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(GetMedium()->GetItemSet(), SID_DOC_SALVAGE, false);
@@ -2611,7 +2577,7 @@ bool SfxObjectShell::CommonSaveAs_Impl(const INetURLObject& aURL, const OUString
 {
     if( aURL.HasError() )
     {
-        SetError( ERRCODE_IO_INVALIDPARAMETER, OSL_LOG_PREFIX );
+        SetError(ERRCODE_IO_INVALIDPARAMETER);
         return false;
     }
 
@@ -2633,7 +2599,7 @@ bool SfxObjectShell::CommonSaveAs_Impl(const INetURLObject& aURL, const OUString
         if ( pDoc )
         {
             // Then error message: "already opened"
-            SetError(ERRCODE_SFX_ALREADYOPEN, OSL_LOG_PREFIX);
+            SetError(ERRCODE_SFX_ALREADYOPEN);
             return false;
         }
     }
@@ -2649,7 +2615,7 @@ bool SfxObjectShell::CommonSaveAs_Impl(const INetURLObject& aURL, const OUString
         || !pFilter->CanExport()
         || (!bSaveTo && !pFilter->CanImport()) )
     {
-        SetError( ERRCODE_IO_INVALIDPARAMETER, OSL_LOG_PREFIX );
+        SetError(ERRCODE_IO_INVALIDPARAMETER);
         return false;
     }
 
@@ -2671,7 +2637,7 @@ bool SfxObjectShell::CommonSaveAs_Impl(const INetURLObject& aURL, const OUString
     if ( aURL == aActName && aURL != INetURLObject( OUString("private:stream") )
         && IsReadOnly() )
     {
-        SetError(ERRCODE_SFX_DOCUMENTREADONLY, OSL_LOG_PREFIX);
+        SetError(ERRCODE_SFX_DOCUMENTREADONLY);
         return false;
     }
 
@@ -2792,7 +2758,7 @@ bool SfxObjectShell::PreDoSaveAs_Impl(const OUString& rFileName, const OUString&
     if ( pNewFile->GetErrorCode() != ERRCODE_NONE )
     {
         // creating temporary file failed ( f.e. floppy disk not inserted! )
-        SetError( pNewFile->GetError(), OSL_LOG_PREFIX );
+        SetError(pNewFile->GetError());
         delete pNewFile;
         return false;
     }
@@ -2813,7 +2779,7 @@ bool SfxObjectShell::PreDoSaveAs_Impl(const OUString& rFileName, const OUString&
     if ( !pNewFile->GetErrorCode() && SaveTo_Impl( *pNewFile, nullptr ) )
     {
         // transfer a possible error from the medium to the document
-        SetError( pNewFile->GetErrorCode(), OSL_LOG_PREFIX );
+        SetError(pNewFile->GetErrorCode());
 
         // notify the document that saving was done successfully
         if ( !bCopyTo )
@@ -2834,7 +2800,7 @@ bool SfxObjectShell::PreDoSaveAs_Impl(const OUString& rFileName, const OUString&
             //       and the DoSaveCompleted call should not be able to fail in general
 
             DBG_ASSERT( !bCopyTo, "Error while reconnecting to medium, can't be handled!");
-            SetError( pNewFile->GetErrorCode(), OSL_LOG_PREFIX );
+            SetError(pNewFile->GetErrorCode());
 
             if ( !bCopyTo )
             {
@@ -2853,7 +2819,7 @@ bool SfxObjectShell::PreDoSaveAs_Impl(const OUString& rFileName, const OUString&
     }
     else
     {
-        SetError( pNewFile->GetErrorCode(), OSL_LOG_PREFIX );
+        SetError(pNewFile->GetErrorCode());
 
         // reconnect to the old storage
         DoSaveCompleted();
diff --git a/sfx2/source/doc/sfxbasemodel.cxx b/sfx2/source/doc/sfxbasemodel.cxx
index 36b6be463497..bd61032c379c 100644
--- a/sfx2/source/doc/sfxbasemodel.cxx
+++ b/sfx2/source/doc/sfxbasemodel.cxx
@@ -1470,7 +1470,6 @@ void SAL_CALL SfxBaseModel::storeSelf( const    Sequence< beans::PropertyValue >
 
     if ( m_pData->m_pObjectShell.is() )
     {
-        m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "storeSelf" );
         SfxSaveGuard aSaveGuard(this, m_pData);
 
         bool bCheckIn = false;
@@ -1484,9 +1483,6 @@ void SAL_CALL SfxBaseModel::storeSelf( const    Sequence< beans::PropertyValue >
               && aSeqArgs[nInd].Name != "FailOnWarning"
               && aSeqArgs[nInd].Name != "CheckIn" )
             {
-                m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "unexpected parameter for storeSelf, might be no problem if SaveAs is executed." );
-                m_pData->m_pObjectShell->StoreLog();
-
                 OUString aMessage( "Unexpected MediaDescriptor parameter: "  );
                 aMessage += aSeqArgs[nInd].Name;
                 throw lang::IllegalArgumentException( aMessage, Reference< XInterface >(), 1 );
@@ -1558,16 +1554,12 @@ void SAL_CALL SfxBaseModel::storeSelf( const    Sequence< beans::PropertyValue >
 
         if ( bRet )
         {
-            m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "successful saving." );
             m_pData->m_aPreusedFilterName = GetMediumFilterName_Impl();
 
             SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveDocDone, GlobalEventConfig::GetEventName(GlobalEventId::SAVEDOCDONE), m_pData->m_pObjectShell.get() ) );
         }
         else
         {
-            m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "Storing failed!" );
-            m_pData->m_pObjectShell->StoreLog();
-
             // write the contents of the logger to the file
             SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveDocFailed, GlobalEventConfig::GetEventName(GlobalEventId::SAVEDOCFAILED), m_pData->m_pObjectShell.get() ) );
 
@@ -1599,7 +1591,6 @@ void SAL_CALL SfxBaseModel::storeAsURL( const   OUString&                   rURL
 
     if ( m_pData->m_pObjectShell.is() )
     {
-        m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "storeAsURL" );
         SfxSaveGuard aSaveGuard(this, m_pData);
 
         impl_store( rURL, rArgs, false );
@@ -1639,7 +1630,6 @@ void SAL_CALL SfxBaseModel::storeToURL( const   OUString&                   rURL
 
     if ( m_pData->m_pObjectShell.is() )
     {
-        m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "storeToURL" );
         SfxSaveGuard aSaveGuard(this, m_pData);
         try {
             impl_store(rURL, rArgs, true);
@@ -2901,9 +2891,6 @@ void SfxBaseModel::impl_store(  const   OUString&                   sURL
                             // TODO/LATER: need a new interaction for this case
                             if ( m_pData->m_pObjectShell->IsDocShared() )
                             {
-                                m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "Can't store shared document!" );
-                                m_pData->m_pObjectShell->StoreLog();
-
                                 uno::Sequence< beans::NamedValue > aNewEncryptionData = aArgHash.getUnpackedValueOrDefault("EncryptionData", uno::Sequence< beans::NamedValue >() );
                                 if ( !aNewEncryptionData.getLength() )
                                 {
@@ -2946,9 +2933,6 @@ void SfxBaseModel::impl_store(  const   OUString&                   sURL
 
         if ( pCopyStreamItem && pCopyStreamItem->GetValue() && !bSaveTo )
         {
-            m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "Misuse of CopyStreamIfPossible!" );
-            m_pData->m_pObjectShell->StoreLog();
-
             throw frame::IllegalArgumentIOException(
                     "CopyStreamIfPossible parameter is not acceptable for storeAsURL() call!" );
         }
@@ -3005,7 +2989,7 @@ void SfxBaseModel::impl_store(  const   OUString&                   sURL
         sal_uInt32 nErrCode = m_pData->m_pObjectShell->GetErrorCode();
         if ( !bRet && !nErrCode )
         {
-            m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "Storing has failed, no error is set!" );
+            SAL_WARN("sfx.doc", "Storing has failed, no error is set!");
             nErrCode = ERRCODE_IO_CANTWRITE;
         }
         m_pData->m_pObjectShell->ResetError();
@@ -3026,7 +3010,6 @@ void SfxBaseModel::impl_store(  const   OUString&                   sURL
                 }
             }
 
-            m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "Storing succeeded!" );
             if ( !bSaveTo )
             {
                 m_pData->m_aPreusedFilterName = GetMediumFilterName_Impl();
@@ -3044,10 +3027,6 @@ void SfxBaseModel::impl_store(  const   OUString&                   sURL
         }
         else
         {
-            // let the logring be stored to the related file
-            m_pData->m_pObjectShell->AddLog( OSL_LOG_PREFIX "Storing failed!" );
-            m_pData->m_pObjectShell->StoreLog();
-
             m_pData->m_pObjectShell->SetModifyPasswordHash( nOldModifyPasswordHash );
             m_pData->m_pObjectShell->SetModifyPasswordInfo( aOldModifyPasswordInfo );
 
diff --git a/sfx2/source/inc/objshimp.hxx b/sfx2/source/inc/objshimp.hxx
index a9348c1cfbbd..ac2de9a9e3dc 100644
--- a/sfx2/source/inc/objshimp.hxx
+++ b/sfx2/source/inc/objshimp.hxx
@@ -23,7 +23,6 @@
 #include <com/sun/star/uno/Sequence.hxx>
 #include <rtl/ustring.hxx>
 #include <rtl/ref.hxx>
-#include <com/sun/star/logging/XSimpleLogRing.hpp>
 #include <tools/datetime.hxx>
 
 #include <unotools/securityoptions.hxx>
@@ -128,8 +127,6 @@ struct SfxObjectShell_Impl : public ::sfx2::IMacroDocumentAccess
 
     OUString            m_aSharedFileURL;
 
-    css::uno::Reference< css::logging::XSimpleLogRing > m_xLogRing;
-
     bool                m_bIncomplEncrWarnShown;
 
     // TODO/LATER: m_aModifyPasswordInfo should completely replace m_nModifyPasswordHash in future
diff --git a/starmath/source/document.cxx b/starmath/source/document.cxx
index fa04a4941b80..f0a274c82de2 100644
--- a/starmath/source/document.cxx
+++ b/starmath/source/document.cxx
@@ -748,7 +748,7 @@ bool SmDocShell::Load( SfxMedium& rMedium )
             SmXMLImportWrapper aEquation(xModel);
             sal_uLong nError = aEquation.Import(rMedium);
             bRet = 0 == nError;
-            SetError( nError, OSL_LOG_PREFIX );
+            SetError(nError);
         }
     }
 
diff --git a/sw/source/uibase/app/docsh.cxx b/sw/source/uibase/app/docsh.cxx
index 6e45da59dc54..58af1d2cd3f3 100644
--- a/sw/source/uibase/app/docsh.cxx
+++ b/sw/source/uibase/app/docsh.cxx
@@ -276,7 +276,7 @@ bool SwDocShell::ConvertFrom( SfxMedium& rMedium )
 
     SW_MOD()->SetEmbeddedLoadSave( false );
 
-    SetError( nErr, OSL_LOG_PREFIX );
+    SetError(nErr);
     bool bOk = !IsError( nErr );
 
     if (bOk && !m_pDoc->IsInLoadAsynchron())
@@ -366,7 +366,7 @@ bool SwDocShell::Save()
         }
         SW_MOD()->SetEmbeddedLoadSave( false );
     }
-    SetError( nErr ? nErr : nVBWarning, OSL_LOG_PREFIX );
+    SetError(nErr ? nErr : nVBWarning);
 
     SfxViewFrame *const pFrame =
         (m_pWrtShell) ? m_pWrtShell->GetView().GetViewFrame() : nullptr;
@@ -512,7 +512,7 @@ bool SwDocShell::SaveAs( SfxMedium& rMedium )
 
         m_pDoc->cleanupUnoCursorTable();
     }
-    SetError( nErr ? nErr : nVBWarning, OSL_LOG_PREFIX );
+    SetError(nErr ? nErr : nVBWarning);
 
     return !IsError( nErr );
 }
@@ -595,7 +595,7 @@ bool SwDocShell::ConvertTo( SfxMedium& rMedium )
                     Sequence<OUString> aModNames = xLib->getElementNames();
                     if(aModNames.getLength())
                     {
-                        SetError(WARN_SWG_HTML_NO_MACROS, OSL_LOG_PREFIX );
+                        SetError(WARN_SWG_HTML_NO_MACROS);
                         break;
                     }
                 }
@@ -751,7 +751,7 @@ bool SwDocShell::ConvertTo( SfxMedium& rMedium )
     }
 
     SW_MOD()->SetEmbeddedLoadSave( false );
-    SetError( nErrno ? nErrno : nVBWarning, OSL_LOG_PREFIX );
+    SetError(nErrno ? nErrno : nVBWarning);
     if( !rMedium.IsStorage() )
         rMedium.CloseOutStream();
 
diff --git a/sw/source/uibase/app/docsh2.cxx b/sw/source/uibase/app/docsh2.cxx
index 9c4af8e901cd..e40383849f63 100644
--- a/sw/source/uibase/app/docsh2.cxx
+++ b/sw/source/uibase/app/docsh2.cxx
@@ -572,7 +572,7 @@ void SwDocShell::Execute(SfxRequest& rReq)
                     bMerge = bool(nFlags & SfxTemplateFlags::MERGE_STYLES);
                     aOpt.SetMerge( !bMerge );
 
-                    SetError( LoadStylesFromFile( aFileName, aOpt, false ), OSL_LOG_PREFIX);
+                    SetError(LoadStylesFromFile(aFileName, aOpt, false));
                     if ( !GetError() )
                         rReq.Done();
                 }
diff --git a/sw/source/uibase/app/docshini.cxx b/sw/source/uibase/app/docshini.cxx
index 9c6663518d99..958985974a94 100644
--- a/sw/source/uibase/app/docshini.cxx
+++ b/sw/source/uibase/app/docshini.cxx
@@ -581,7 +581,7 @@ bool  SwDocShell::Load( SfxMedium& rMedium )
         UpdateFontList();
         InitDrawModelAndDocShell(this, m_pDoc ? m_pDoc->getIDocumentDrawModelAccess().GetDrawModel() : nullptr);
 
-        SetError( nErr, OSL_LOG_PREFIX );
+        SetError(nErr);
         bRet = !IsError( nErr );
 
         if (bRet && !m_pDoc->IsInLoadAsynchron() &&
@@ -630,7 +630,7 @@ bool  SwDocShell::LoadFrom( SfxMedium& rMedium )
             OSL_FAIL("Code removed!");
         }
 
-        SetError( nErr, OSL_LOG_PREFIX );
+        SetError(nErr);
         bRet = !IsError( nErr );
 
     } while( false );