diff options
Diffstat (limited to 'src')
4 files changed, 197 insertions, 9 deletions
diff --git a/src/DotNetOpenAuth/OpenId/RelyingParty/FailedAuthenticationResponse.cs b/src/DotNetOpenAuth/OpenId/RelyingParty/FailedAuthenticationResponse.cs index f899f03..e4dbc9a 100644 --- a/src/DotNetOpenAuth/OpenId/RelyingParty/FailedAuthenticationResponse.cs +++ b/src/DotNetOpenAuth/OpenId/RelyingParty/FailedAuthenticationResponse.cs @@ -31,6 +31,7 @@ namespace DotNetOpenAuth.OpenId.RelyingParty { Contract.Requires<ArgumentNullException>(exception != null); this.Exception = exception; + Reporting.RecordEventOccurrence(this); } #region IAuthenticationResponse Members diff --git a/src/DotNetOpenAuth/OpenId/RelyingParty/NegativeAuthenticationResponse.cs b/src/DotNetOpenAuth/OpenId/RelyingParty/NegativeAuthenticationResponse.cs index 02c5185..2669634 100644 --- a/src/DotNetOpenAuth/OpenId/RelyingParty/NegativeAuthenticationResponse.cs +++ b/src/DotNetOpenAuth/OpenId/RelyingParty/NegativeAuthenticationResponse.cs @@ -30,6 +30,8 @@ namespace DotNetOpenAuth.OpenId.RelyingParty { internal NegativeAuthenticationResponse(NegativeAssertionResponse response) { Contract.Requires<ArgumentNullException>(response != null); this.response = response; + + Reporting.RecordEventOccurrence(this); } #region IAuthenticationResponse Properties diff --git a/src/DotNetOpenAuth/OpenId/RelyingParty/PositiveAnonymousResponse.cs b/src/DotNetOpenAuth/OpenId/RelyingParty/PositiveAnonymousResponse.cs index 1bc306c..08d0350 100644 --- a/src/DotNetOpenAuth/OpenId/RelyingParty/PositiveAnonymousResponse.cs +++ b/src/DotNetOpenAuth/OpenId/RelyingParty/PositiveAnonymousResponse.cs @@ -39,6 +39,8 @@ namespace DotNetOpenAuth.OpenId.RelyingParty { if (response.ProviderEndpoint != null && response.Version != null) { this.provider = new ProviderEndpointDescription(response.ProviderEndpoint, response.Version); } + + Reporting.RecordEventOccurrence(this); } #region IAuthenticationResponse Properties diff --git a/src/DotNetOpenAuth/Reporting.cs b/src/DotNetOpenAuth/Reporting.cs index 45ee6db..79451b8 100644 --- a/src/DotNetOpenAuth/Reporting.cs +++ b/src/DotNetOpenAuth/Reporting.cs @@ -36,6 +36,15 @@ namespace DotNetOpenAuth { private static readonly TimeSpan minimumReportingInterval = TimeSpan.FromDays(1); /// <summary> + /// The maximum frequency the set can be flushed to disk. + /// </summary> +#if DEBUG + private static readonly TimeSpan minimumFlushInterval = TimeSpan.Zero; +#else + private static readonly TimeSpan minimumFlushInterval = TimeSpan.FromMinutes(15); +#endif + + /// <summary> /// The isolated storage to use for collecting data in between published reports. /// </summary> private static IsolatedStorageFile file; @@ -76,6 +85,11 @@ namespace DotNetOpenAuth { private static List<PersistentHashSet> observations = new List<PersistentHashSet>(); /// <summary> + /// The named events that we have counters for. + /// </summary> + private static Dictionary<string, PersistentCounter> events = new Dictionary<string, PersistentCounter>(StringComparer.OrdinalIgnoreCase); + + /// <summary> /// The lock acquired while considering whether to publish a report. /// </summary> private static object publishingConsiderationLock = new object(); @@ -122,6 +136,32 @@ namespace DotNetOpenAuth { private static bool Enabled { get; set; } /// <summary> + /// Records an event occurrence. + /// </summary> + /// <param name="eventName">Name of the event.</param> + internal static void RecordEventOccurrence(string eventName) { + Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(eventName)); + + PersistentCounter counter; + lock (events) { + if (!events.TryGetValue(eventName, out counter)) { + events[eventName] = counter = new PersistentCounter(file, "event-" + SanitizeFileName(eventName) + ".txt"); + } + } + + counter.Increment(); + } + + /// <summary> + /// Records an event occurence. + /// </summary> + /// <param name="eventNameByObjectType">The object whose type name is the event name to record.</param> + internal static void RecordEventOccurrence(object eventNameByObjectType) { + Contract.Requires<ArgumentNullException>(eventNameByObjectType != null); + RecordEventOccurrence(eventNameByObjectType.GetType().Name); + } + + /// <summary> /// Records the use of a feature by name. /// </summary> /// <param name="feature">The feature.</param> @@ -229,6 +269,7 @@ namespace DotNetOpenAuth { writer.WriteLine(Util.LibraryVersion); foreach (var observation in observations) { + observation.Flush(); writer.WriteLine("===================================="); writer.WriteLine(observation.FileName); try { @@ -241,6 +282,19 @@ namespace DotNetOpenAuth { } } + foreach (var counter in events.Values) { + counter.Flush(); + } + + foreach (string eventFile in file.GetFileNames("event-*.txt")) { + writer.WriteLine("===================================="); + writer.WriteLine(eventFile); + using (var fileStream = new IsolatedStorageFileStream(eventFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, file)) { + writer.Flush(); + fileStream.CopyTo(writer.BaseStream); + } + } + // Make sure the stream is positioned at the beginning. writer.Flush(); stream.Position = 0; @@ -321,6 +375,28 @@ namespace DotNetOpenAuth { } /// <summary> + /// Sanitizes the name of the file so it only includes valid filename characters. + /// </summary> + /// <param name="fileName">The filename to sanitize.</param> + /// <returns>The filename, with any and all invalid filename characters replaced with the hyphen (-) character.</returns> + private static string SanitizeFileName(string fileName) { + Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(fileName)); + char[] invalidCharacters = Path.GetInvalidFileNameChars(); + if (fileName.IndexOfAny(invalidCharacters) < 0) { + return fileName; // nothing invalid about this filename. + } + + // Use a stringbuilder since we may be replacing several characters + // and we don't want to instantiate a new string buffer for each new version. + StringBuilder sanitized = new StringBuilder(fileName); + foreach (char invalidChar in invalidCharacters) { + sanitized.Replace(invalidChar, '-'); + } + + return sanitized.ToString(); + } + + /// <summary> /// A set of values that persist the set to disk. /// </summary> private class PersistentHashSet : IDisposable { @@ -345,15 +421,6 @@ namespace DotNetOpenAuth { private readonly HashSet<string> memorySet = new HashSet<string>(StringComparer.OrdinalIgnoreCase); /// <summary> - /// The maximum frequency the set can be flushed to disk. - /// </summary> -#if DEBUG - private static readonly TimeSpan minimumFlushInterval = TimeSpan.Zero; -#else - private static readonly TimeSpan minimumFlushInterval = TimeSpan.FromMinutes(15); -#endif - - /// <summary> /// The maximum number of elements to track before not storing new elements. /// </summary> private readonly int maximumElements; @@ -484,5 +551,121 @@ namespace DotNetOpenAuth { } } } + + /// <summary> + /// A feature usage counter. + /// </summary> + private class PersistentCounter : IDisposable { + /// <summary> + /// The isolated persistent storage. + /// </summary> + private readonly FileStream fileStream; + + /// <summary> + /// The persistent reader. + /// </summary> + private readonly StreamReader reader; + + /// <summary> + /// The persistent writer. + /// </summary> + private readonly StreamWriter writer; + + /// <summary> + /// The time the last flush occurred. + /// </summary> + private DateTime lastFlushed; + + /// <summary> + /// The in-memory copy of the counter. + /// </summary> + private int counter; + + /// <summary> + /// A flag indicating whether the set has changed since it was last flushed. + /// </summary> + private bool dirty; + + /// <summary> + /// Initializes a new instance of the <see cref="PersistentCounter"/> class. + /// </summary> + /// <param name="storage">The storage location.</param> + /// <param name="fileName">Name of the file.</param> + internal PersistentCounter(IsolatedStorageFile storage, string fileName) { + Contract.Requires<ArgumentNullException>(storage != null); + Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(fileName)); + this.FileName = fileName; + + // Load the file into memory. + bool fileCreated = storage.GetFileNames(fileName).Length == 0; + this.fileStream = new IsolatedStorageFileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read, storage); + this.reader = new StreamReader(this.fileStream, Encoding.UTF8); + int.TryParse(this.reader.ReadLine(), out this.counter); + + this.writer = new StreamWriter(this.fileStream, Encoding.UTF8); + this.writer.AutoFlush = true; + this.lastFlushed = DateTime.Now; + + // Write a unique header to the file so the report collector can match duplicates. + if (fileCreated) { + this.writer.WriteLine(Guid.NewGuid().ToString("B")); + } + } + + /// <summary> + /// Gets the name of the file. + /// </summary> + /// <value>The name of the file.</value> + internal string FileName { get; private set; } + + #region IDisposable Members + + /// <summary> + /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + /// </summary> + public void Dispose() { + this.Dispose(true); + } + + #endregion + + /// <summary> + /// Increments the counter. + /// </summary> + internal void Increment() { + lock (this) { + this.counter++; + this.dirty = true; + if (this.dirty && DateTime.Now - this.lastFlushed > minimumFlushInterval) { + this.Flush(); + } + } + } + + /// <summary> + /// Flushes any newly added values to disk. + /// </summary> + internal void Flush() { + lock (this) { + this.writer.BaseStream.Position = 0; + this.writer.BaseStream.SetLength(0); // truncate file + this.writer.Write(this.counter); + this.dirty = false; + this.lastFlushed = DateTime.Now; + } + } + + /// <summary> + /// Releases unmanaged and - optionally - managed resources + /// </summary> + /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> + protected virtual void Dispose(bool disposing) { + if (disposing) { + this.writer.Dispose(); + this.reader.Dispose(); + this.fileStream.Dispose(); + } + } + } } } |