feat!: upgrade to NHibernate 5.1

hazzik · hazzik · commit 4ad0cc6d8ae9 · 2022-10-03T18:28:07.000+13:00
diff --git a/src/NHibernate.Search/Backend/Impl/Lucene/LuceneWorker.cs b/src/NHibernate.Search/Backend/Impl/Lucene/LuceneWorker.cs
@@ -11,7 +11,7 @@ namespace NHibernate.Search.Backend.Impl.Lucene
 {
     public class LuceneWorker
     {
-		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(LuceneWorker));
+		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(LuceneWorker));
         private readonly Workspace workspace;
 
         #region Constructors
@@ -62,7 +62,7 @@ public void PerformWork(DeleteLuceneWork work, IDirectoryProvider provider)
         public void PerformWork(OptimizeLuceneWork work, IDirectoryProvider provider)
         {
             System.Type entity = work.EntityClass;
-            if (log.IsDebugEnabled)
+            if (log.IsDebugEnabled())
             {
                 log.Debug("Optimize Lucene index: " + entity);
             }
@@ -82,7 +82,7 @@ public void PerformWork(OptimizeLuceneWork work, IDirectoryProvider provider)
         public void PerformWork(PurgeAllLuceneWork work, IDirectoryProvider provider)
         {
             System.Type entity = work.EntityClass;
-            if (log.IsDebugEnabled)
+            if (log.IsDebugEnabled())
             {
                 log.Debug("PurgeAll Lucene index: " + entity);
             }
@@ -105,7 +105,7 @@ public void PerformWork(PurgeAllLuceneWork work, IDirectoryProvider provider)
 
         private void Add(System.Type entity, object id, Document document, IDirectoryProvider provider)
         {
-            if (log.IsDebugEnabled)
+            if (log.IsDebugEnabled())
             {
                 log.Debug("Add to Lucene index: " + entity + "#" + id + ": " + document);
             }
@@ -129,7 +129,7 @@ private void Remove(System.Type entity, object id, IDirectoryProvider provider)
             * We can only delete by term, and the index doesn't have a termt that
             * uniquely identify the entry. See logic below
             */
-            log.DebugFormat("remove from Lucene index: {0}#{1}", entity, id);
+            log.Debug("remove from Lucene index: {0}#{1}", entity, id);
             DocumentBuilder builder = workspace.GetDocumentBuilder(entity);
             Term term = builder.GetTerm(id);
             IndexReader reader = workspace.GetIndexReader(provider, entity);
@@ -165,7 +165,7 @@ private void Remove(System.Type entity, object id, IDirectoryProvider provider)
                     }
                     catch (IOException e)
                     {
-                        log.Warn("Unable to close termDocs properly", e);
+                        log.Warn(e, "Unable to close termDocs properly");
                     }
                 }
             }
diff --git a/src/NHibernate.Search/Backend/Workspace.cs b/src/NHibernate.Search/Backend/Workspace.cs
@@ -24,7 +24,7 @@ namespace NHibernate.Search.Backend
     /// TODO introduce the notion of read only IndexReader? We cannot enforce it because Lucene use abstract classes, not interfaces
     public class Workspace : IDisposable
     {
-		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(Workspace));
+		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(Workspace));
 
         private readonly Dictionary<IDirectoryProvider, IndexReader> readers;
         private readonly Dictionary<IDirectoryProvider, IndexWriter> writers;
@@ -236,7 +236,7 @@ private void CleanUp(SearchException originalException)
                 {
                     if (raisedException != null)
                     {
-                        log.Error("Subsequent Exception while closing IndexReader", e);
+                        log.Error(e, "Subsequent Exception while closing IndexReader");
                     }
                     else
                     {
@@ -280,7 +280,7 @@ private void CleanUp(SearchException originalException)
                 {
                     if (raisedException != null)
                     {
-                        log.Error("Subsequent Exception while closing IndexWriter", e);
+                        log.Error(e, "Subsequent Exception while closing IndexWriter");
                     }
                     else
                     {
diff --git a/src/NHibernate.Search/Engine/DocumentBuilder.cs b/src/NHibernate.Search/Engine/DocumentBuilder.cs
@@ -26,7 +26,7 @@ namespace NHibernate.Search.Engine
     public class DocumentBuilder
     {
         public const string CLASS_FIELDNAME = "_hibernate_class";
-		private static readonly IInternalLogger logger = LoggerProvider.LoggerFor(typeof(DocumentBuilder));
+		private static readonly INHibernateLogger logger = NHibernateLogger.For(typeof(DocumentBuilder));
 
         private readonly IDirectoryProvider[] directoryProviders;
         private readonly IIndexShardingStrategy shardingStrategy;
@@ -288,9 +288,7 @@ private void BuildDocumentFields(Object instance, Document doc, DocumentMapping
                 }
                 catch (Exception e)
                 {
-                    logger.Error(
-                        string.Format(CultureInfo.InvariantCulture, "Error processing class bridge for {0}",
-                                      bridgeName), e);
+                    logger.Error(e, string.Format(CultureInfo.InvariantCulture, "Error processing class bridge for {0}", bridgeName));
                 }
             }
 
@@ -322,9 +320,7 @@ private void BuildDocumentField(FieldMapping fieldMapping, object unproxiedInsta
             }
             catch (Exception e)
             {
-                logger.Error(
-                    string.Format(CultureInfo.InvariantCulture, "Error processing field bridge for {0}.{1}",
-                                  unproxiedInstance.GetType().FullName, fieldName), e);
+                logger.Error(e, string.Format(CultureInfo.InvariantCulture, "Error processing field bridge for {0}.{1}", unproxiedInstance.GetType().FullName, fieldName));
             }
         }
 
@@ -490,9 +486,9 @@ private static void PopulateResult(
                 if (fieldStore != Attributes.Store.No && fieldBridge is ITwoWayFieldBridge)
                 {
                     result[matchingPosition] = ((ITwoWayFieldBridge)fieldBridge).Get(fieldName, document);
-                    if (logger.IsInfoEnabled)
+                    if (logger.IsInfoEnabled())
                     {
-                        logger.Info("Field " + fieldName + " projected as " + result[matchingPosition]);
+                        logger.Info("Field {0} projected as {1}", fieldName, result[matchingPosition]);
                     }
                 }
                 else
diff --git a/src/NHibernate.Search/Engine/ObjectLoader.cs b/src/NHibernate.Search/Engine/ObjectLoader.cs
@@ -5,7 +5,7 @@ namespace NHibernate.Search.Engine
 {
     public partial class ObjectLoader : ILoader
     {
-        private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(ObjectLoader));
+        private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(ObjectLoader));
 
         private ISession session;
 
diff --git a/src/NHibernate.Search/Engine/QueryLoader.cs b/src/NHibernate.Search/Engine/QueryLoader.cs
@@ -6,7 +6,7 @@ namespace NHibernate.Search.Engine
 {
     public partial class QueryLoader : ILoader
     {
-		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(QueryLoader));
+		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(QueryLoader));
         private static readonly IList EMPTY_LIST = new ArrayList();
         private const int MAX_IN_CLAUSE = 500;
 
diff --git a/src/NHibernate.Search/Event/FullTextIndexCollectionEventListener.cs b/src/NHibernate.Search/Event/FullTextIndexCollectionEventListener.cs
@@ -12,7 +12,7 @@ namespace NHibernate.Search.Event
     public partial class FullTextIndexCollectionEventListener : FullTextIndexEventListener, 
                                     IPostCollectionRecreateEventListener, IPostCollectionRemoveEventListener, IPostCollectionUpdateEventListener
     {
-		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(FullTextIndexCollectionEventListener));
+		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(FullTextIndexCollectionEventListener));
 
         #region Public methods
 
diff --git a/src/NHibernate.Search/Impl/SearchFactoryImpl.cs b/src/NHibernate.Search/Impl/SearchFactoryImpl.cs
@@ -24,7 +24,7 @@ namespace NHibernate.Search.Impl
 {
     public class SearchFactoryImpl : ISearchFactoryImplementor
     {
-		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(SearchFactoryImpl));
+		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(SearchFactoryImpl));
         private static readonly object searchFactoryKey = new object();
 
         private readonly ISearchMapping mapping;
@@ -235,7 +235,7 @@ public void Close()
                 }
                 catch (Exception e)
                 {
-                    log.Error("ReaderProvider raises an exception on destroy()", e);
+                    log.Error(e, "ReaderProvider raises an exception on destroy()");
                 }
             }
         }
diff --git a/src/NHibernate.Search/Mapping/AttributeBased/AttributeSearchMappingBuilder.cs b/src/NHibernate.Search/Mapping/AttributeBased/AttributeSearchMappingBuilder.cs
@@ -19,7 +19,7 @@ namespace NHibernate.Search.Mapping.AttributeBased
     using Type = System.Type;
     
     public class AttributeSearchMappingBuilder {
-		private static readonly IInternalLogger logger = LoggerProvider.LoggerFor(typeof(AttributeSearchMappingBuilder));
+		private static readonly INHibernateLogger logger = NHibernateLogger.For(typeof(AttributeSearchMappingBuilder));
 
         private int level;
         private int maxLevel = int.MaxValue;
@@ -290,7 +290,7 @@ private void BuildProperty(
                     documentMapping.Embedded.Add(embedded);
                     context.Processed.Remove(actualFieldType); // pop
                 }
-                else if (logger.IsDebugEnabled)
+                else if (logger.IsDebugEnabled())
                 {
                     logger.Debug("Depth reached, ignoring " + path + localPrefix);
                 }
diff --git a/src/NHibernate.Search/Mapping/AttributeBased/AttributeUtil.cs b/src/NHibernate.Search/Mapping/AttributeBased/AttributeUtil.cs
@@ -9,7 +9,7 @@ namespace NHibernate.Search.Mapping.AttributeBased
 {
     public class AttributeUtil
     {
-		private static readonly IInternalLogger logger = LoggerProvider.LoggerFor(typeof(AttributeUtil));
+		private static readonly INHibernateLogger logger = NHibernateLogger.For(typeof(AttributeUtil));
 
         #region Public methods
 
diff --git a/src/NHibernate.Search/NHibernate.Search.csproj b/src/NHibernate.Search/NHibernate.Search.csproj
@@ -23,7 +23,7 @@
   </ItemGroup>
   <ItemGroup>
 	<PackageReference Include="Lucene.Net" Version="2.9.4.1" />
-    <PackageReference Include="NHibernate" Version="5.0.8" />
+    <PackageReference Include="NHibernate" Version="5.1.7" />
     <PackageReference Include="Iesi.Collections" Version="4.0.4" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/NHibernate.Search/Query/FullTextQueryImpl.cs b/src/NHibernate.Search/Query/FullTextQueryImpl.cs
@@ -21,7 +21,7 @@ namespace NHibernate.Search.Query
 
     public partial class FullTextQueryImpl : QueryImpl, IFullTextQuery
     {
-		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(FullTextQueryImpl));
+		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(FullTextQueryImpl));
         private readonly Dictionary<string, FullTextFilterImpl> filterDefinitions;
         private readonly Lucene.Net.Search.Query luceneQuery;
         private System.Type[] classes;
@@ -409,7 +409,7 @@ private TopDocs GetTopDocs(Searcher searcher)
                 BuildFilters();
                 TopDocs topDocs = searcher.Search(query, this.filter, int.MaxValue, this.sort ?? Sort.RELEVANCE);
 
-                log.DebugFormat("Lucene query returned {0} results", topDocs.TotalHits);
+                log.Debug("Lucene query returned {0} results", topDocs.TotalHits);
                 this.SetResultSize(topDocs);
 
                 return topDocs;
@@ -418,7 +418,7 @@ private TopDocs GetTopDocs(Searcher searcher)
 
         private void LogQuery()
         {
-            if (log.IsDebugEnabled == false)
+            if (log.IsDebugEnabled() == false)
             {
                 return;
             }
@@ -449,7 +449,7 @@ private void LogQuery()
                 firstRow = -1;
             }
 
-            log.DebugFormat("Execute lucene query [{0}]: {1}. Max rows: {2}, First result: {3}", sb, luceneQuery, maxRows, firstRow);
+            log.Debug("Execute lucene query [{0}]: {1}. Max rows: {2}, First result: {3}", sb, luceneQuery, maxRows, firstRow);
         }
 
         private void BuildFilters()
@@ -576,7 +576,7 @@ private void CloseSearcher(IndexSearcher searcher)
                 }
                 catch (IOException e)
                 {
-                    log.Warn("Unable to properly close searcher during lucene query: " + QueryString, e);
+                    log.Warn(e, "Unable to properly close searcher during lucene query: " + QueryString);
                 }
             }
         }
diff --git a/src/NHibernate.Search/Reader/SharedReaderProvider.cs b/src/NHibernate.Search/Reader/SharedReaderProvider.cs
@@ -16,7 +16,7 @@ namespace NHibernate.Search.Reader
     /// </summary>
     public class SharedReaderProvider : IReaderProvider
     {
-		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(SharedReaderProvider));
+		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(SharedReaderProvider));
         private static FieldInfo subReadersField;
 
         /// <summary>
@@ -51,7 +51,7 @@ public class SharedReaderProvider : IReaderProvider
         private IndexReader ReplaceActiveReader(IndexReader outOfDateReader, object directoryProviderLock,
                                                 IDirectoryProvider directoryProvider, IndexReader[] readers)
         {
-            bool trace = log.IsInfoEnabled;
+            bool trace = log.IsInfoEnabled();
             IndexReader oldReader;
             bool closeOldReader = false;
             bool closeOutOfDateReader = false;
@@ -150,7 +150,7 @@ private IndexReader ReplaceActiveReader(IndexReader outOfDateReader, object dire
 
         public IndexReader OpenReader(IDirectoryProvider[] directoryProviders)
         {
-            bool trace = log.IsInfoEnabled;
+            bool trace = log.IsInfoEnabled();
             int length = directoryProviders.Length;
             IndexReader[] readers = new IndexReader[length];
 
@@ -221,7 +221,7 @@ public IndexReader OpenReader(IDirectoryProvider[] directoryProviders)
 
         public void CloseReader(IndexReader reader)
         {
-            bool trace = log.IsInfoEnabled;
+            bool trace = log.IsInfoEnabled();
             if (reader == null) return;
             IndexReader[] readers;
 
@@ -313,7 +313,7 @@ private void CloseInternalReader(bool trace, IndexReader subReader, bool finalCl
                 }
                 catch (IOException e)
                 {
-                    log.Warn("Unable to close Lucene IndexReader", e);
+                    log.Warn(e, "Unable to close Lucene IndexReader");
                 }
             }
         }
@@ -339,7 +339,7 @@ public void Initialize(IDictionary<string, string> properties,
 
         public void Destroy()
         {
-            bool trace = log.IsInfoEnabled;
+            bool trace = log.IsInfoEnabled();
             List<IndexReader> readers;
             lock (semaphoreIndexReaderLock)
             {
diff --git a/src/NHibernate.Search/Store/FSDirectoryProvider.cs b/src/NHibernate.Search/Store/FSDirectoryProvider.cs
@@ -13,7 +13,7 @@ namespace NHibernate.Search.Store
 {
     public class FSDirectoryProvider : IDirectoryProvider
     {
-		private static IInternalLogger log = LoggerProvider.LoggerFor(typeof(FSDirectoryProvider));
+		private static INHibernateLogger log = NHibernateLogger.For(typeof(FSDirectoryProvider));
         private FSDirectory directory;
         private String indexName;
 
diff --git a/src/NHibernate.Search/Store/FSMasterDirectoryProvider.cs b/src/NHibernate.Search/Store/FSMasterDirectoryProvider.cs
@@ -22,7 +22,7 @@ namespace NHibernate.Search.Store
     /// </summary>
     public class FSMasterDirectoryProvider : IDirectoryProvider
     {
-		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(FSMasterDirectoryProvider));
+		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(FSMasterDirectoryProvider));
         private FSDirectory directory;
         private int current;
         private string indexName;
@@ -88,7 +88,7 @@ public void Initialize(string directoryProviderName, IDictionary<string, string>
                 bool create = !IndexReader.IndexExists(directory);
                 if (create)
                 {
-                    log.DebugFormat("Index directory not found, creating '{0}'", indexDir.FullName);
+                    log.Debug("Index directory not found, creating '{0}'", indexDir.FullName);
                     indexDir.Create();
                 }
 
@@ -118,7 +118,7 @@ public void Start()
                 log.Warn("Error parsing refresh period, defaulting to 1 hour");
             }
 
-            log.DebugFormat("Refresh period {0} seconds", period);            
+            log.Debug("Refresh period {0} seconds", period);            
             period *= 1000;  // per second
 
             try
@@ -134,7 +134,7 @@ public void Start()
                 }
                 else
                 {
-                    log.DebugFormat("Source directory for '{0}' will be initialized", indexName);
+                    log.Debug("Source directory for '{0}' will be initialized", indexName);
                     current = 1;
                 }
 
@@ -252,7 +252,7 @@ public void Run()
                         catch (IOException e)
                         {
                             // Don't change current
-                            log.Error("Unable to synchronize source of " + parent.indexName, e);
+                            log.Error(e, "Unable to synchronize source of " + parent.indexName);
                             return;
                         }
 
@@ -262,7 +262,7 @@ public void Run()
                         }
                         catch (IOException e)
                         {
-                            log.Warn("Unable to remove previous marker file from source of " + parent.indexName, e);
+                            log.Warn(e, "Unable to remove previous marker file from source of " + parent.indexName);
                         }
 
                         try
@@ -271,7 +271,7 @@ public void Run()
                         }
                         catch (IOException e)
                         {
-                            log.Warn("Unable to create current marker in source of " + parent.indexName, e);
+                            log.Warn(e, "Unable to create current marker in source of " + parent.indexName);
                         }
                     }
                 }
@@ -280,7 +280,7 @@ public void Run()
                     inProgress = false;
                 }
 
-                log.InfoFormat("Copy for {0} took {1}.", parent.indexName, (DateTime.Now - start));
+                log.Info("Copy for {0} took {1}.", parent.indexName, (DateTime.Now - start));
             }
 
             #endregion
diff --git a/src/NHibernate.Search/Store/FSSlaveDirectoryProvider.cs b/src/NHibernate.Search/Store/FSSlaveDirectoryProvider.cs
diff --git a/src/NHibernate.Search/Store/FileHelper.cs b/src/NHibernate.Search/Store/FileHelper.cs
diff --git a/src/NHibernate.Search/Store/Optimization/IncrementalOptimizerStrategy.cs b/src/NHibernate.Search/Store/Optimization/IncrementalOptimizerStrategy.cs
diff --git a/src/NHibernate.Search/Util/DirectoryProviderHelper.cs b/src/NHibernate.Search/Util/DirectoryProviderHelper.cs

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace NHibernate.Search.Backend.Impl.Lucene`
`11`	`11`	`{`
`12`	`12`	`public class LuceneWorker`
`13`	`13`	`{`
`14`		`- private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(LuceneWorker));`
	`14`	`+ private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(LuceneWorker));`
`15`	`15`	`private readonly Workspace workspace;`
`16`	`16`
`17`	`17`	`#region Constructors`
`@@ -62,7 +62,7 @@ public void PerformWork(DeleteLuceneWork work, IDirectoryProvider provider)`
`62`	`62`	`public void PerformWork(OptimizeLuceneWork work, IDirectoryProvider provider)`
`63`	`63`	`{`
`64`	`64`	`System.Type entity = work.EntityClass;`
`65`		`- if (log.IsDebugEnabled)`
	`65`	`+ if (log.IsDebugEnabled())`
`66`	`66`	`{`
`67`	`67`	`log.Debug("Optimize Lucene index: " + entity);`
`68`	`68`	`}`
`@@ -82,7 +82,7 @@ public void PerformWork(OptimizeLuceneWork work, IDirectoryProvider provider)`
`82`	`82`	`public void PerformWork(PurgeAllLuceneWork work, IDirectoryProvider provider)`
`83`	`83`	`{`
`84`	`84`	`System.Type entity = work.EntityClass;`
`85`		`- if (log.IsDebugEnabled)`
	`85`	`+ if (log.IsDebugEnabled())`
`86`	`86`	`{`
`87`	`87`	`log.Debug("PurgeAll Lucene index: " + entity);`
`88`	`88`	`}`
`@@ -105,7 +105,7 @@ public void PerformWork(PurgeAllLuceneWork work, IDirectoryProvider provider)`
`105`	`105`
`106`	`106`	`private void Add(System.Type entity, object id, Document document, IDirectoryProvider provider)`
`107`	`107`	`{`
`108`		`- if (log.IsDebugEnabled)`
	`108`	`+ if (log.IsDebugEnabled())`
`109`	`109`	`{`
`110`	`110`	`log.Debug("Add to Lucene index: " + entity + "#" + id + ": " + document);`
`111`	`111`	`}`
`@@ -129,7 +129,7 @@ private void Remove(System.Type entity, object id, IDirectoryProvider provider)`
`129`	`129`	`* We can only delete by term, and the index doesn't have a termt that`
`130`	`130`	`* uniquely identify the entry. See logic below`
`131`	`131`	`*/`
`132`		`- log.DebugFormat("remove from Lucene index: {0}#{1}", entity, id);`
	`132`	`+ log.Debug("remove from Lucene index: {0}#{1}", entity, id);`
`133`	`133`	`DocumentBuilder builder = workspace.GetDocumentBuilder(entity);`
`134`	`134`	`Term term = builder.GetTerm(id);`
`135`	`135`	`IndexReader reader = workspace.GetIndexReader(provider, entity);`
`@@ -165,7 +165,7 @@ private void Remove(System.Type entity, object id, IDirectoryProvider provider)`
`165`	`165`	`}`
`166`	`166`	`catch (IOException e)`
`167`	`167`	`{`
`168`		`- log.Warn("Unable to close termDocs properly", e);`
	`168`	`+ log.Warn(e, "Unable to close termDocs properly");`
`169`	`169`	`}`
`170`	`170`	`}`
`171`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ namespace NHibernate.Search.Backend`
`24`	`24`	`/// TODO introduce the notion of read only IndexReader? We cannot enforce it because Lucene use abstract classes, not interfaces`
`25`	`25`	`public class Workspace : IDisposable`
`26`	`26`	`{`
`27`		`- private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(Workspace));`
	`27`	`+ private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(Workspace));`
`28`	`28`
`29`	`29`	`private readonly Dictionary<IDirectoryProvider, IndexReader> readers;`
`30`	`30`	`private readonly Dictionary<IDirectoryProvider, IndexWriter> writers;`
`@@ -236,7 +236,7 @@ private void CleanUp(SearchException originalException)`
`236`	`236`	`{`
`237`	`237`	`if (raisedException != null)`
`238`	`238`	`{`
`239`		`- log.Error("Subsequent Exception while closing IndexReader", e);`
	`239`	`+ log.Error(e, "Subsequent Exception while closing IndexReader");`
`240`	`240`	`}`
`241`	`241`	`else`
`242`	`242`	`{`
`@@ -280,7 +280,7 @@ private void CleanUp(SearchException originalException)`
`280`	`280`	`{`
`281`	`281`	`if (raisedException != null)`
`282`	`282`	`{`
`283`		`- log.Error("Subsequent Exception while closing IndexWriter", e);`
	`283`	`+ log.Error(e, "Subsequent Exception while closing IndexWriter");`
`284`	`284`	`}`
`285`	`285`	`else`
`286`	`286`	`{`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ namespace NHibernate.Search.Engine`
`26`	`26`	`public class DocumentBuilder`
`27`	`27`	`{`
`28`	`28`	`public const string CLASS_FIELDNAME = "_hibernate_class";`
`29`		`- private static readonly IInternalLogger logger = LoggerProvider.LoggerFor(typeof(DocumentBuilder));`
	`29`	`+ private static readonly INHibernateLogger logger = NHibernateLogger.For(typeof(DocumentBuilder));`
`30`	`30`
`31`	`31`	`private readonly IDirectoryProvider[] directoryProviders;`
`32`	`32`	`private readonly IIndexShardingStrategy shardingStrategy;`
`@@ -288,9 +288,7 @@ private void BuildDocumentFields(Object instance, Document doc, DocumentMapping`
`288`	`288`	`}`
`289`	`289`	`catch (Exception e)`
`290`	`290`	`{`
`291`		`- logger.Error(`
`292`		`- string.Format(CultureInfo.InvariantCulture, "Error processing class bridge for {0}",`
`293`		`- bridgeName), e);`
	`291`	`+ logger.Error(e, string.Format(CultureInfo.InvariantCulture, "Error processing class bridge for {0}", bridgeName));`
`294`	`292`	`}`
`295`	`293`	`}`
`296`	`294`
`@@ -322,9 +320,7 @@ private void BuildDocumentField(FieldMapping fieldMapping, object unproxiedInsta`
`322`	`320`	`}`
`323`	`321`	`catch (Exception e)`
`324`	`322`	`{`
`325`		`- logger.Error(`
`326`		`- string.Format(CultureInfo.InvariantCulture, "Error processing field bridge for {0}.{1}",`
`327`		`- unproxiedInstance.GetType().FullName, fieldName), e);`
	`323`	`+ logger.Error(e, string.Format(CultureInfo.InvariantCulture, "Error processing field bridge for {0}.{1}", unproxiedInstance.GetType().FullName, fieldName));`
`328`	`324`	`}`
`329`	`325`	`}`
`330`	`326`
`@@ -490,9 +486,9 @@ private static void PopulateResult(`
`490`	`486`	`if (fieldStore != Attributes.Store.No && fieldBridge is ITwoWayFieldBridge)`
`491`	`487`	`{`
`492`	`488`	`result[matchingPosition] = ((ITwoWayFieldBridge)fieldBridge).Get(fieldName, document);`
`493`		`- if (logger.IsInfoEnabled)`
	`489`	`+ if (logger.IsInfoEnabled())`
`494`	`490`	`{`
`495`		`- logger.Info("Field " + fieldName + " projected as " + result[matchingPosition]);`
	`491`	`+ logger.Info("Field {0} projected as {1}", fieldName, result[matchingPosition]);`
`496`	`492`	`}`
`497`	`493`	`}`
`498`	`494`	`else`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace NHibernate.Search.Engine`
`5`	`5`	`{`
`6`	`6`	`public partial class ObjectLoader : ILoader`
`7`	`7`	`{`
`8`		`- private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(ObjectLoader));`
	`8`	`+ private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(ObjectLoader));`
`9`	`9`
`10`	`10`	`private ISession session;`
`11`	`11`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace NHibernate.Search.Engine`
`6`	`6`	`{`
`7`	`7`	`public partial class QueryLoader : ILoader`
`8`	`8`	`{`
`9`		`- private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(QueryLoader));`
	`9`	`+ private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(QueryLoader));`
`10`	`10`	`private static readonly IList EMPTY_LIST = new ArrayList();`
`11`	`11`	`private const int MAX_IN_CLAUSE = 500;`
`12`	`12`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace NHibernate.Search.Event`
`12`	`12`	`public partial class FullTextIndexCollectionEventListener : FullTextIndexEventListener,`
`13`	`13`	`IPostCollectionRecreateEventListener, IPostCollectionRemoveEventListener, IPostCollectionUpdateEventListener`
`14`	`14`	`{`
`15`		`- private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(FullTextIndexCollectionEventListener));`
	`15`	`+ private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(FullTextIndexCollectionEventListener));`
`16`	`16`
`17`	`17`	`#region Public methods`
`18`	`18`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ namespace NHibernate.Search.Mapping.AttributeBased`
`19`	`19`	`using Type = System.Type;`
`20`	`20`
`21`	`21`	`public class AttributeSearchMappingBuilder {`
`22`		`- private static readonly IInternalLogger logger = LoggerProvider.LoggerFor(typeof(AttributeSearchMappingBuilder));`
	`22`	`+ private static readonly INHibernateLogger logger = NHibernateLogger.For(typeof(AttributeSearchMappingBuilder));`
`23`	`23`
`24`	`24`	`private int level;`
`25`	`25`	`private int maxLevel = int.MaxValue;`
`@@ -290,7 +290,7 @@ private void BuildProperty(`
`290`	`290`	`documentMapping.Embedded.Add(embedded);`
`291`	`291`	`context.Processed.Remove(actualFieldType); // pop`
`292`	`292`	`}`
`293`		`- else if (logger.IsDebugEnabled)`
	`293`	`+ else if (logger.IsDebugEnabled())`
`294`	`294`	`{`
`295`	`295`	`logger.Debug("Depth reached, ignoring " + path + localPrefix);`
`296`	`296`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace NHibernate.Search.Mapping.AttributeBased`
`9`	`9`	`{`
`10`	`10`	`public class AttributeUtil`
`11`	`11`	`{`
`12`		`- private static readonly IInternalLogger logger = LoggerProvider.LoggerFor(typeof(AttributeUtil));`
	`12`	`+ private static readonly INHibernateLogger logger = NHibernateLogger.For(typeof(AttributeUtil));`
`13`	`13`
`14`	`14`	`#region Public methods`
`15`	`15`