Introduce tracing

Edward Thomson · Edward Thomson · commit 959453b19fcc · 2014-09-18T13:09:33.000-04:00
diff --git a/Lib/NativeBinaries/amd64/git2-69db893.dll b/Lib/NativeBinaries/amd64/git2-69db893.dll
diff --git a/Lib/NativeBinaries/amd64/git2-69db893.pdb b/Lib/NativeBinaries/amd64/git2-69db893.pdb
diff --git a/Lib/NativeBinaries/x86/git2-69db893.dll b/Lib/NativeBinaries/x86/git2-69db893.dll
diff --git a/Lib/NativeBinaries/x86/git2-69db893.pdb b/Lib/NativeBinaries/x86/git2-69db893.pdb
diff --git a/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj b/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
@@ -124,6 +124,7 @@
     <Compile Include="TestHelpers\SelfCleaningDirectory.cs" />
     <Compile Include="TestHelpers\SignatureExtensions.cs" />
     <Compile Include="TestHelpers\SkippableFactAttribute.cs" />
+    <Compile Include="TraceFixture.cs" />
     <Compile Include="TreeDefinitionFixture.cs" />
     <Compile Include="TreeFixture.cs" />
     <Compile Include="UnstageFixture.cs" />
diff --git a/LibGit2Sharp.Tests/TestHelpers/DirectoryHelper.cs b/LibGit2Sharp.Tests/TestHelpers/DirectoryHelper.cs
@@ -47,7 +47,7 @@ public static void DeleteDirectory(string directoryPath)
 
             if (!Directory.Exists(directoryPath))
             {
-                Trace.WriteLine(
+                System.Diagnostics.Trace.WriteLine(
                     string.Format("Directory '{0}' is missing and can't be removed.",
                         directoryPath));
 
@@ -75,7 +75,7 @@ public static void DeleteDirectory(string directoryPath)
             }
             catch (IOException)
             {
-                Trace.WriteLine(string.Format("{0}The directory '{1}' could not be deleted!" +
+                System.Diagnostics.Trace.WriteLine(string.Format("{0}The directory '{1}' could not be deleted!" +
                                                     "{0}Most of the time, this is due to an external process accessing the files in the temporary repositories created during the test runs, and keeping a handle on the directory, thus preventing the deletion of those files." +
                                                     "{0}Known and common causes include:" +
                                                     "{0}- Windows Search Indexer (go to the Indexing Options, in the Windows Control Panel, and exclude the bin folder of LibGit2Sharp.Tests)" +
diff --git a/LibGit2Sharp.Tests/TraceFixture.cs b/LibGit2Sharp.Tests/TraceFixture.cs
@@ -0,0 +1,54 @@
+﻿using System;
+using LibGit2Sharp;
+using LibGit2Sharp.Core;
+using Xunit;
+
+namespace LibGit2Sharp.Tests
+{
+    public class TraceFixture
+    {
+        [Fact]
+        public void CanEnableAndDisableTracing()
+        {
+            TraceLevel level = TraceLevel.None;
+            string message = null;
+
+            GlobalSettings.TraceConfiguration = new TraceConfiguration(TraceLevel.Info, (l, m) => { level = l; message = m; });
+            Trace.Write(TraceLevel.Info, "This is an informative trace.");
+
+            Assert.Equal(TraceLevel.Info, level);
+            Assert.Equal("This is an informative trace.", message);
+
+            level = TraceLevel.None;
+            message = null;
+
+            GlobalSettings.TraceConfiguration = TraceConfiguration.None;
+            Trace.Write(TraceLevel.Error, "This will not be traced since tracing is disabled.");
+
+            Assert.Equal(TraceLevel.None, level);
+            Assert.Equal(null, message);
+        }
+
+        [Fact]
+        public void CanEasilyDetermineIfTracingIsEnabled()
+        {
+            GlobalSettings.TraceConfiguration = new TraceConfiguration(TraceLevel.Info, (l, m) => { });
+
+            Assert.Equal(true, Trace.IsEnabled(TraceLevel.Fatal));
+            Assert.Equal(true, Trace.IsEnabled(TraceLevel.Error));
+            Assert.Equal(true, Trace.IsEnabled(TraceLevel.Warning));
+            Assert.Equal(true, Trace.IsEnabled(TraceLevel.Info));
+            Assert.Equal(false, Trace.IsEnabled(TraceLevel.Debug));
+            Assert.Equal(false, Trace.IsEnabled(TraceLevel.Trace));
+
+            GlobalSettings.TraceConfiguration = TraceConfiguration.None;
+
+            Assert.Equal(false, Trace.IsEnabled(TraceLevel.Fatal));
+            Assert.Equal(false, Trace.IsEnabled(TraceLevel.Error));
+            Assert.Equal(false, Trace.IsEnabled(TraceLevel.Warning));
+            Assert.Equal(false, Trace.IsEnabled(TraceLevel.Info));
+            Assert.Equal(false, Trace.IsEnabled(TraceLevel.Debug));
+            Assert.Equal(false, Trace.IsEnabled(TraceLevel.Trace));
+        }
+    }
+}
diff --git a/LibGit2Sharp/Core/Handles/SafeHandleBase.cs b/LibGit2Sharp/Core/Handles/SafeHandleBase.cs
@@ -35,11 +35,11 @@ protected override void Dispose(bool disposing)
         {
             if (!disposing && !IsInvalid)
             {
-                Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "A {0} handle wrapper has not been properly disposed.", GetType().Name));
+                System.Diagnostics.Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "A {0} handle wrapper has not been properly disposed.", GetType().Name));
 #if LEAKS
                 Trace.WriteLine(trace);
 #endif
-                Trace.WriteLine("");
+                System.Diagnostics.Trace.WriteLine("");
             }
 
             base.Dispose(disposing);
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
@@ -1492,6 +1492,11 @@ internal static extern int git_tag_delete(
         [DllImport(libgit2)]
         internal static extern void git_threads_shutdown();
 
+        internal delegate void git_trace_cb(TraceLevel level, IntPtr message);
+
+        [DllImport(libgit2)]
+        internal static extern int git_trace_set(TraceLevel level, git_trace_cb trace_cb);
+
         internal delegate int git_transfer_progress_callback(ref GitTransferProgress stats, IntPtr payload);
 
         internal delegate int git_transport_cb(out IntPtr transport, IntPtr remote, IntPtr payload);
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -2937,6 +2937,19 @@ public static GitObjectType git_tag_target_type(GitObjectSafeHandle tag)
 
         #endregion
 
+        #region git_trace_
+
+        public static void git_trace_set(TraceLevel level, NativeMethods.git_trace_cb callback)
+        {
+            using (ThreadAffinity())
+            {
+                int res = NativeMethods.git_trace_set(level, callback);
+                Ensure.ZeroResult(res);
+            }
+        }
+
+        #endregion
+
         #region git_transport_
 
         public static void git_transport_register(String prefix, IntPtr transport_cb, IntPtr param)
diff --git a/LibGit2Sharp/GlobalSettings.cs b/LibGit2Sharp/GlobalSettings.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using LibGit2Sharp.Core;
+using LibGit2Sharp.Handlers;
 
 namespace LibGit2Sharp
 {
@@ -10,6 +11,8 @@ public static class GlobalSettings
     {
         private static readonly Lazy<Version> version = new Lazy<Version>(Version.Build);
 
+        private static TraceConfiguration traceConfiguration = TraceConfiguration.None;
+
         /// <summary>
         /// Returns all the optional features that were compiled into
         /// libgit2.
@@ -84,5 +87,36 @@ public static void UnregisterSmartSubtransport<T>(SmartSubtransportRegistration<
             Proxy.git_transport_unregister(registration.Scheme);
             registration.Free();
         }
+
+        /// <summary>
+        /// Registers a new <see cref="TraceConfiguration"/> to receive
+        /// trace information from libgit2.
+        ///
+        /// Note that this configuration is global to an entire process
+        /// and does not honor application domains.
+        /// </summary>
+        public static TraceConfiguration TraceConfiguration
+        {
+            set
+            {
+                Ensure.ArgumentNotNull(value, "value");
+
+                traceConfiguration = value;
+
+                if (traceConfiguration.Level == TraceLevel.None)
+                {
+                    Proxy.git_trace_set(0, null);
+                }
+                else
+                {
+                    Proxy.git_trace_set(value.Level, value.GitTraceHandler);
+                }
+            }
+
+            get
+            {
+                return traceConfiguration;
+            }
+        }
     }
 }
diff --git a/LibGit2Sharp/Handlers.cs b/LibGit2Sharp/Handlers.cs
@@ -111,4 +111,12 @@ public enum PackBuilderStage
         /// </summary>
         Deltafying
     }
+
+    /// <summary>
+    /// Delegate definition for tracing.  This callback will be used when
+    /// tracing occurs in libgit2.
+    /// </summary>
+    /// <param name="level">The level of the trace message.</param>
+    /// <param name="message">The trace message.</param>
+    public delegate void TraceHandler(TraceLevel level, string message);
 }
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -138,6 +138,9 @@
     <Compile Include="StageOptions.cs" />
     <Compile Include="StatusOptions.cs" />
     <Compile Include="SimilarityOptions.cs" />
+    <Compile Include="Trace.cs" />
+    <Compile Include="TraceConfiguration.cs" />
+    <Compile Include="TraceLevel.cs" />
     <Compile Include="UnbornBranchException.cs" />
     <Compile Include="LockedFileException.cs" />
     <Compile Include="Core\GitRepositoryInitOptions.cs" />
diff --git a/LibGit2Sharp/Trace.cs b/LibGit2Sharp/Trace.cs
@@ -0,0 +1,26 @@
+﻿using System.Runtime.CompilerServices;
+using LibGit2Sharp.Core;
+
+[assembly: InternalsVisibleTo("LibGit2Sharp.Tests")]
+namespace LibGit2Sharp
+{
+    internal class Trace
+    {
+        internal static bool IsEnabled(TraceLevel level)
+        {
+            TraceConfiguration configuration = GlobalSettings.TraceConfiguration;
+
+            return (configuration.Level != TraceLevel.None && configuration.Level >= level);
+        }
+
+        internal static void Write(TraceLevel level, string message)
+        {
+            TraceConfiguration configuration = GlobalSettings.TraceConfiguration;
+
+            if (configuration.Level != TraceLevel.None && configuration.Level >= level)
+            {
+                configuration.Handler(level, message);
+            }
+        }
+    }
+}
diff --git a/LibGit2Sharp/TraceConfiguration.cs b/LibGit2Sharp/TraceConfiguration.cs
@@ -0,0 +1,45 @@
+﻿using System;
+using LibGit2Sharp.Core;
+using LibGit2Sharp.Handlers;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// Tracing configuration for libgit2 and LibGit2Sharp.
+    /// </summary>
+    public class TraceConfiguration
+    {
+        /// <summary>
+        /// The default tracing configuration, which performs no tracing at all.
+        /// </summary>
+        public static readonly TraceConfiguration None = new TraceConfiguration { Level = TraceLevel.None };
+
+        /// <summary>
+        /// Creates a new tracing configuration to call the given
+        /// delegate when tracing occurs at the given level.
+        /// </summary>
+        /// <param name="level">Level to trace at</param>
+        /// <param name="handler">Handler to call when tracing occurs</param>
+        public TraceConfiguration(TraceLevel level, TraceHandler handler)
+        {
+            Ensure.ArgumentConformsTo<TraceLevel>(level, (t) => { return (level != TraceLevel.None); }, "level");
+            Ensure.ArgumentNotNull(handler, "handler");
+
+            Level = level;
+            Handler = handler;
+        }
+
+        protected TraceConfiguration()
+        {
+        }
+
+        internal TraceLevel Level { get; private set; }
+        internal TraceHandler Handler { get; set; }
+
+        internal void GitTraceHandler(TraceLevel level, IntPtr msg)
+        {
+            string message = LaxUtf8Marshaler.FromNative(msg);
+            Handler(level, message);
+        }
+    }
+}
diff --git a/LibGit2Sharp/TraceLevel.cs b/LibGit2Sharp/TraceLevel.cs
@@ -0,0 +1,50 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// Available tracing levels.  When tracing is enabled at a particular
+    /// level, callers will be provided tracing at the given level and all
+    /// lower levels.
+    /// </summary>
+    public enum TraceLevel
+    {
+        /// <summary>
+        /// No tracing will be provided.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Severe errors that may impact the program's execution.
+        /// </summary>
+        Fatal = 1,
+
+        /// <summary>
+        /// Errors that do not impact the program's execution.
+        /// </summary>
+        Error = 2,
+
+        /// <summary>
+        /// Warnings that suggest abnormal data.
+        /// </summary>
+        Warning = 3,
+
+        /// <summary>
+        /// Informational messages about program execution.
+        /// </summary>
+        Info = 4,
+
+        /// <summary>
+        /// Detailed data that allows for debugging.
+        /// </summary>
+        Debug = 5,
+
+        /// <summary>
+        /// Execptionally detailed debugging data.
+        /// </summary>
+        Trace = 6,
+    }
+}
diff --git a/UpdateLibgit2ToSha.ps1 b/UpdateLibgit2ToSha.ps1
@@ -144,7 +144,7 @@ function Assert-Consistent-Naming($expected, $path) {
 	Run-Command -Quiet { & remove-item build -recurse -force }
 	Run-Command -Quiet { & mkdir build }
 	cd build
-	Run-Command -Quiet -Fatal { & $cmake -G "Visual Studio $vs" -D THREADSAFE=ON -D "BUILD_CLAR=$build_clar" -D "LIBGIT2_FILENAME=$binaryFilename" -DSTDCALL=ON .. }
+	Run-Command -Quiet -Fatal { & $cmake -G "Visual Studio $vs" -D THREADSAFE=ON -D ENABLE_TRACE=ON -D "BUILD_CLAR=$build_clar" -D "LIBGIT2_FILENAME=$binaryFilename" -DSTDCALL=ON .. }
 	Run-Command -Quiet -Fatal { & $cmake --build . --config $configuration }
 	if ($test.IsPresent) { Run-Command -Quiet -Fatal { & $ctest -V . } }
 	cd $configuration
@@ -157,7 +157,7 @@ function Assert-Consistent-Naming($expected, $path) {
 	cd ..
 	Run-Command -Quiet { & mkdir build64 }
 	cd build64
-	Run-Command -Quiet -Fatal { & $cmake -G "Visual Studio $vs Win64" -D THREADSAFE=ON -D "BUILD_CLAR=$build_clar" -D "LIBGIT2_FILENAME=$binaryFilename" -DSTDCALL=ON ../.. }
+	Run-Command -Quiet -Fatal { & $cmake -G "Visual Studio $vs Win64" -D THREADSAFE=ON -D ENABLE_TRACE=ON -D "BUILD_CLAR=$build_clar" -D "LIBGIT2_FILENAME=$binaryFilename" -DSTDCALL=ON ../.. }
 	Run-Command -Quiet -Fatal { & $cmake --build . --config $configuration }
 	if ($test.IsPresent) { Run-Command -Quiet -Fatal { & $ctest -V . } }
 	cd $configuration
diff --git a/build.libgit2sharp.sh b/build.libgit2sharp.sh
@@ -12,6 +12,7 @@ cmake -DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo \
       -DTHREADSAFE:BOOL=ON \
       -DBUILD_CLAR:BOOL=OFF \
       -DUSE_SSH=OFF \
+      -DENABLE_TRACE=ON \
       -DLIBGIT2_FILENAME=git2-$SHORTSHA \
       -DCMAKE_OSX_ARCHITECTURES="i386;x86_64" \
       ..

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public static void DeleteDirectory(string directoryPath)`
`47`	`47`
`48`	`48`	`if (!Directory.Exists(directoryPath))`
`49`	`49`	`{`
`50`		`- Trace.WriteLine(`
	`50`	`+ System.Diagnostics.Trace.WriteLine(`
`51`	`51`	`string.Format("Directory '{0}' is missing and can't be removed.",`
`52`	`52`	`directoryPath));`
`53`	`53`
`@@ -75,7 +75,7 @@ public static void DeleteDirectory(string directoryPath)`
`75`	`75`	`}`
`76`	`76`	`catch (IOException)`
`77`	`77`	`{`
`78`		`- Trace.WriteLine(string.Format("{0}The directory '{1}' could not be deleted!" +`
	`78`	`+ System.Diagnostics.Trace.WriteLine(string.Format("{0}The directory '{1}' could not be deleted!" +`
`79`	`79`	`"{0}Most of the time, this is due to an external process accessing the files in the temporary repositories created during the test runs, and keeping a handle on the directory, thus preventing the deletion of those files." +`
`80`	`80`	`"{0}Known and common causes include:" +`
`81`	`81`	`"{0}- Windows Search Indexer (go to the Indexing Options, in the Windows Control Panel, and exclude the bin folder of LibGit2Sharp.Tests)" +`
Original file line number	Diff line number	Diff line change
`@@ -35,11 +35,11 @@ protected override void Dispose(bool disposing)`
`35`	`35`	`{`
`36`	`36`	`if (!disposing && !IsInvalid)`
`37`	`37`	`{`
`38`		`- Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "A {0} handle wrapper has not been properly disposed.", GetType().Name));`
	`38`	`+ System.Diagnostics.Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "A {0} handle wrapper has not been properly disposed.", GetType().Name));`
`39`	`39`	`#if LEAKS`
`40`	`40`	`Trace.WriteLine(trace);`
`41`	`41`	`#endif`
`42`		`- Trace.WriteLine("");`
	`42`	`+ System.Diagnostics.Trace.WriteLine("");`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`base.Dispose(disposing);`