MARKUS

<?xml version="1.0"?>

<doc>

    <assembly>

        <name>EQATEC.Analytics.Monitor</name>

    </assembly>

    <members>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitor">

            <summary>

            Implementing class for IAnalyticsMonitor. Coordinates the interaction between

            the messaging subsystem, the statistics and the storage

            </summary>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor">

            <summary>

            The main interface for the analytics monitor which can be obtained with a call to 

            <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(System.String)"/> or <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)"/>. The monitor will not collect data before

            a call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/> has been performed.

            </summary>

            <remarks>For more on the features of the EQATEC Analytics service please

            refer to the <a href="http://eqatec.com/analytics">EQATEC Analytics website</a></remarks>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start">

            <summary>

            Call to start the monitor. When started the monitor will begin collecting data from the

            calls and send them asynchronously to the EQATEC Analytics servers on background threads

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception)">

            <summary>

            Call to track an exception that occured in the application.

            </summary>

            <param name="exception">the exception to be tracked</param>

            <example>An example of tracking an exception

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main()

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   // your application logic here

                }

                catch(Exception exc)

                {

                  // catch-all handle 

                  monitor.TrackException(exc);

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String)">

            <summary>

            Call to track an exception that occured in the application.

            </summary>

            <param name="exception">The exception to be tracked</param>

            <param name="contextMessage">Contextual information about the action being performed when the exception occurred</param>

            <example>An example of tracking an exception

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main(string[] args)

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   // your application logic here

                }

                catch(Exception exc)

                {

                  // catch-all handle 

                  monitor.TrackException(exc, "CatchAllHandler");

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])">

            <summary>

            Call to track an exception that occured in the application.

            </summary>

            <param name="exception">The exception to be tracked</param>

            <param name="contextMessageFormat">A context message string containing the information about the action being performed when the exception occurred</param>

            <param name="args">An object array containing zero or more objects to format the <paramref name="contextMessageFormat"/></param>

            <example>An example of tracking an exception

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main(string[] args)

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   // your application logic here

                }

                catch(Exception exc)

                {

                  // catch-all handle 

                  monitor.TrackException(exc, "CatchAllHandler with argument count {0}", args.Length);

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)">

            <summary>

            Register a feature usage. It is recommended that related features are grouped by using simple dot-notation

            in the <paramref name="featureName"/> such as e.g. relating print to pdf and print to file by naming the

            features "print.pdf" and "print.file" respectively

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track features in your application

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main(string[] args)

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   bool exportToFile = ShouldExportToFile(); //omitted for brevity

                   if (exportToFile)

                     monitor.TrackFeature("export.file");

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatures(System.String[])">

            <summary>

            Register a number of feature usages. For the individual feature names, it is recommended that related 

            features are grouped by using simple dot-notation such as e.g. relating print to pdf and print to file by naming the

            features "print.pdf" and "print.file" respectively. This allow call is semantically equivalent to

            calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/> multiple times.

            </summary>

            <param name="featureNames">The array of named feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track features in your application

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main(string[] args)

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   bool exportToFile = ShouldExportToFile(); //omitted for brevity

                   if (exportToFile)

                     monitor.TrackFeature(new[]{"export.file", "export.byuser"});

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)">

            <summary>

            Register the start of a feature usage. Use this with <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> to track

            how long a feature is used.

            </summary>

            <returns>A <see cref="T:EQATEC.Analytics.Monitor.TimingScope"/> instance that can be used for creating more compact timing code.</returns>

            <remarks>There cannot be more then one feature timing running with a given <paramref name="featureName"/> at a time.

            This implies that calling this method multiple times with the same <paramref name="featureName"/> has no effect

            until the existing time has termined by either calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> or 

            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)"/> with the same <paramref name="featureName"/>. All features timings

            are implicitly stopped by calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/>.</remarks>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track feature time in your application

            <code>

            class SomeClass

            {   

              private IAnalyticsMonitor m_monitor;

              public SomeClass(IAnalyticsMonitor monitor)

              {

                m_monitor = monitor;

              }

              public void Process()

              {

                try 

                {

                   m_monitor.TrackFeatureStart("SomeClass.Process");

                   //some process logic to time

                   m_monitor.TrackFeatureStop("SomeClass.Process");

                }

                catch(Exception exc)

                {

                  m_monitor.TrackFeatureCancel("SomeClass.Process");

                  throw;

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)">

            <summary>

            Register the end of a feature usage stared by <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> with a similar

            <paramref name="featureName"/>.

            </summary>

            <returns>The total time tracked for this feature or <c>TimeSpan.Zero</c> if timing was not tracked</returns>

            <remarks>Calling this method with a <paramref name="featureName"/> that does not match an already

            started feature timing has no effect. All features timings

            are implicitly stopped by calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/>.

            </remarks>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track feature time in your application

            <code>

            class SomeClass

            {   

              private IAnalyticsMonitor m_monitor;

              public SomeClass(IAnalyticsMonitor monitor)

              {

                m_monitor = monitor;

              }

              public void Process()

              {

                try 

                {

                   m_monitor.TrackFeatureStart("SomeClass.Process");

                   //some process logic to time

                   TimeSpan timeSpent = m_monitor.TrackFeatureStop("SomeClass.Process");

                }

                catch(Exception exc)

                {

                  m_monitor.TrackFeatureCancel("SomeClass.Process");

                  throw;

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)">

            <summary>

            Stops an ongoing timing of a feature from any previous call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> with similar

            <paramref name="featureName"/> without

            registering the time spent. Use this call if the feature being tracked did not complete as expected, e.g.

            was interupted by an exception. The call can safely be made even if no <c>TrackFeatureStart</c> has

            been made.

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track feature time in your application

            <code>

            class SomeClass

            {   

              private IAnalyticsMonitor m_monitor;

              public SomeClass(IAnalyticsMonitor monitor)

              {

                m_monitor = monitor;

              }

              public void Process()

              {

                try 

                {

                   m_monitor.TrackFeatureStart("SomeClass.Process");

                   //some process logic to time

                   m_monitor.TrackFeatureStop("SomeClass.Process");

                }

                catch(Exception exc)

                {

                  m_monitor.TrackFeatureCancel("SomeClass.Process");

                  throw;

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureValue(System.String,System.Int64)">

            <summary>

            Register a value on a specific feature. 

            </summary>

            <remarks>While calls to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/> increments the use of a feature in the session a call to

            this methods will associate a given value with a named feature. Use this method to e.g. track the distribution

            of file sizes imported or the number of results registered. Tracking this distribution across all your application

            usage will give insights to what scenarios your applications are handling</remarks>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <param name="trackedValue">The value to track</param>

            <example>The following shows an example of how you can track feature values in your application

            <code>

            class SomeClass

            {   

              private IAnalyticsMonitor m_monitor;

              public SomeClass(IAnalyticsMonitor monitor)

              {

                m_monitor = monitor;

              }

              public void Process()

              {

                int filesProcessed = ProcessFiles();

                m_monitor.TrackFeatureValue("SomeClass.FilesProcessed", filesProcessed);

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop">

            <summary>

            Call to stop the monitor. Call will attempt to save any pending state

            to the storage and send the final tracking data to the servers. 

            </summary>

            <remarks>This call will attempt to send the final tracking data to the servers on a background thread and

            by wait for completion of this monitor processing for up to 2 seconds. If you do not want to wait for up to 2 seconds

            for the completion of this operation, please consider using the overload to this function(<see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop(System.TimeSpan)"/>.</remarks>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop(System.TimeSpan)">

            <summary>

            Call to stop the monitor. The monitor will attempt to save any pending state

            to the storage and send the final tracking data to the servers. The <paramref name="waitForCompletion"/> can be specified

            to allow for the thread to wait for completion of data persistence and transmission. If the monitor cannot complete

            before the specified time the call will return.

            </summary>

            <param name="waitForCompletion">The time to wait for the stop to complete successfully. Use <see cref="F:System.TimeSpan.Zero"/> to avoid waiting for completion.</param>

            <remarks>This call will attempt to send the final tracking data to the servers on a background thread and

            by providing a <paramref name="waitForCompletion"/> timeout you increase the chance that the monitor is able to

            completion the transmission while the runtime and threadpools are still operational. If no timeout is specified

            the monitors background threads and network connections may be removed as part of the process termination and thereby

            leaving data in the cache to be delivered on the next startup.</remarks>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync">

            <summary>

            Explicitly force a synchonization of the current information with the analytics server. 

            </summary>

            <remarks>This call is not expected to be used in a standard setup but may be helpful in occasionally connected 

            scenarios. You can use this method in conjunction with setting <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.SynchronizeAutomatically"/> to <c>false</c>

            in order to take control of when data is attempted to be delivered to the servers. By default the monitor will

            control the data delivery internally but if you need to decide e.g. when networks can be utilized you

            can use this method to schedule an asynchronous data delivery

            </remarks>

            <seealso cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})">

            <summary>

            Associates an installation ID with the current session and optionally a dictionary of

            installation properties that allows you to add additional installation meta data for the session

            </summary>

            <remarks>Use this method to register you installationid on the monitor and optionally associate

            installation properties with this installation id. You can call this method multiple times

            while the monitor is running and thus alter the installation id associated with the session at runtime. Note however

            that changing the installation id will also reset any previous installation properties associated with the previous 

            installation id from the session so you will need to associate them again</remarks>

            <param name="installationId">The installation ID to associate with the current session</param>

            <param name="propertyDictionary">The dictionary containing the key-value pairs for the installation properties of the current session</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)">

            <summary>

            Associates an installation ID with the current session 

            </summary>

            <remarks>Use this method to register you installationid on the monitor. You can call this method multiple times

            while the monitor is running and thus alter the installation id associated with the session at runtime. Note however

            that changing the installation id will also reset any previous installation properties associated with the previous 

            installation id from the session so you will need to associate them again</remarks>

            <param name="installationId">The installation ID to associate with the current session</param>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Status">

            <summary>

            Access the current status for the monitor.

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Start">

            <summary>

            Initializes the monitor

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Stop">

            <summary>

            Stop the Analytics monitor. Will attempt to write any pending

            state to the storage

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Stop(System.TimeSpan)">

            <summary>

            Stop the Analytics monitor. Will attempt to write any pending

            state to the storage

            </summary>

            <param name="waitForCompletion">The timeout for any server communication in progress</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception)">

            <summary>

            Track exception

            </summary>

            <param name="exception"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception,System.String)">

            <summary>

            Track exception

            </summary>

            <param name="exception"></param>

            <param name="contextMessage"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])">

            <summary>

            Track exception

            </summary>

            <param name="exception"></param>

            <param name="contextMessageFormat"></param>

            <param name="args"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureStart(System.String)">

            <summary>

            Tracking a feature start

            </summary>

            <param name="featureName"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureStop(System.String)">

            <summary>

            Tracking a feature stop

            </summary>

            <param name="featureName"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureCancel(System.String)">

            <summary>

            Cancelling a feature timing

            </summary>

            <param name="featureName"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.ForceSync">

            <summary>

            Force a synchonization the current information with the analytics server.

            This should not be used in normal situations.

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.SetInstallationInfo(System.String)">

            <summary>

            Set installationId at the current session

            </summary>

            <param name="installationId">the installation ID</param>

            <returns></returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})">

            <summary>

            Set installationId at the current session and get interface to installation settings

            </summary>

            <param name="installationId">the installation ID</param>

            <param name="installationProperties">the installaion properties</param>

            <returns></returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.System#IDisposable#Dispose">

            <summary>

            Dispose the monitor

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitor.Status">

            <summary>

            Access the current status for the monitor.

            </summary>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade">

             <summary>

             Represents a simple facade for interacting with the Analytics Monitor. Use this facade interface instead

             of interacting more directly with the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory"/> and <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/>

             interfaces for a slightly higher level interaction model.

             </summary>

             <remarks>

             The facade will instantiate a single <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance on the Create call and

             the remaining methods on this class mirror the methods found on the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface. The

             facade can be used by consumers as a simple way of calling the API without worrying about passing the

             <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance around and about the timing issues of when the methods can be 

             called. The facade will encapsulate the created instance, raise an exception for multiple calls

             to the <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(System.String)"/> methods and will forward the methods on to the instance when it is available.

             If the facade represent too high level control or you would like to control the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/>

             instance yourself you should look at using the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory"/> methods.

             Repeated calls to the Create methods will raise exceptions as the intended use of the facade is for simple integration scenarios</remarks>

             <example> This sample shows how to use AnalyticsMonitorFacade.

             <code>

             class MyClass 

             {

               static void Main()

               {

                 //Creating Analytics Monitor

                 AnalyticsMonitorFacade.Create("YOUR_PRODUCT_KEY_HERE");

                 //Start Analytics monitor

                 AnalyticsMonitorFacade.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 AnalyticsMonitorFacade.Stop();

               }

             }

             </code>

             </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(System.String)">

            <summary>

            Initializes the facade by creating a monitor with the given product id and the standard

            settings

            </summary>

            <param name="productId">the product id to use</param>

            <exception cref="T:System.InvalidOperationException">if Create has already been called</exception>

            <exception cref="T:System.ArgumentException">if the product id is not correctly formatted</exception>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)">

            <summary>

            Initializes the facade by creating a monitor with the specified

            settings

            </summary>

            <param name="settings">the product id to use</param>

            <exception cref="T:System.InvalidOperationException">if Create has already been called</exception>

            <exception cref="T:System.ArgumentNullException">if <c>null</c> is passed as settings</exception>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Start">

            <summary>

            Start the monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/> method

            </summary>

            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Stop">

            <summary>

            Stop the monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/> method

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Stop(System.TimeSpan)">

             <summary>

             Stop the monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop(System.TimeSpan)"/> method

             </summary>

            <param name="waitForCompletion">The wait interval for the monitor to stop correctly</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception)">

            <summary>

            Track an exception. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception)"/> method

            </summary>

            <param name="exception">the exception instance</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception,System.String)">

            <summary>

            Track an exception along with a context message. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String)"/> method

            </summary>

            <param name="exception">the exception instance</param>

            <param name="message">an additional context message specifying extra information not captured in the exception</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception,System.String,System.Object[])">

            <summary>

            Track an exception with a formatted context message. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])"/> method

            </summary>

            <param name="exception">the exception instance</param>

            <param name="format">a format string for specifying extra information not captured in the exception</param>

            <param name="args">arguments to the format string</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeature(System.String)">

            <summary>

            Register a feature usage. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatures(System.String[])">

            <summary>

            Register a number of feature usages. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatures(System.String[])"/> method

            </summary>

            <param name="featureNames">Array of named features. If it is <c>null</c> or empty the request is ignored.</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStart(System.String)">

            <summary>

            Register the start of a feature usage. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <returns>A <see cref="T:EQATEC.Analytics.Monitor.TimingScope"/> instance that can be used for creating more compact timing code.</returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStop(System.String)">

            <summary>

            Register the end of a feature usage stared by <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStart(System.String)"/>.Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureCancel(System.String)">

            <summary>

            Cancels an ongoing feature timing tracking. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureValue(System.String,System.Int64)">

            <summary>

            Tracks a value on a named feature. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureValue(System.String,System.Int64)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <param name="value">The value to be tracked</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.ForceSync">

            <summary>

            Force a sync for manual synchronization. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync"/> call.

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})">

            <summary>

            Sets the installation id for the current monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})"/> call

            </summary>

            <param name="installationID">The current installation id to assign</param>

            <param name="installationProperties">The key-value pairs for the installation properties</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.SetInstallationInfo(System.String)">

            <summary>

            Sets the installation id for the current monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)"/> call

            </summary>

            <param name="installationID">The current installation id to assign</param>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Status">

            <summary>

            Get the current capabilities of the wrapped monitor

            </summary>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory">

            <summary>

            Factory for creating <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instances. Call with an instance of 

            <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> to customize behavior of the constructed monitor.

            </summary>

            <remarks>While it is possible to create multiple monitors for the same product id from within

            the same application it is not encouraged as it may lead to inconsistencies in data stored on disk.</remarks>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(System.String)">

             <summary>

             Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance using the default settings

             </summary>

             <param name="productId">the product ID</param>

             <returns>an instance of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface</returns>

             <exception cref="T:System.ArgumentException">thrown if product id provided have the wrong format (guid format expected)</exception>

             <example> This sample shows how to start the Analytics monitor.

             <code>

             class MyClass 

             {

               static void Main() 

               {

                 //Creating IAnalyticsMonitor

                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR_PRODUCT_KEY_HERE");

                 //Start Analytics monitor

                 monitor.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 monitor.Stop();

               }

             }

             </code>

             </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)">

             <summary>

             Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance using the customized settings in the

             <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance.

             </summary>

             <param name="settings">the settings to use for constructing the instance</param>

             <returns>an instance of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface</returns>

             <exception cref="T:System.ArgumentNullException">thrown if the <paramref name="settings"/> is <c>null</c></exception>

             <example> This sample shows how to start the Analytics monitor.

             <code>

             class MyClass 

             {

               static void Main() 

               {

                 //Creating AnalyticsMonitorSettings

                 AnalyticsMonitorSettings settings = new AnalyticsMonitorSettings("YOUR_PRODUCT_KEY_HERE");

                 settings.TestMode = true;

                 //Creating IAnalyticsMonitor

                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create(settings);

                 //Start Analytics monitor

                 monitor.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 monitor.Stop();

               }

             }

             </code>

             </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)">

             <summary>

             Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance using the customized settings in the

             <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance.

             </summary>

             <param name="settings">the settings to use for constructing the instance</param>

             <returns>an instance of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface</returns>

             <exception cref="T:System.ArgumentNullException">thrown if product the <paramref name="settings"/> is <c>null</c></exception>

             <example> This sample shows how to start the Analytics monitor.

             <code>

             class MyClass 

             {

               static void Main() 

               {

                 //Creating AnalyticsMonitorSettings

                 AnalyticsMonitorSettings settings = new AnalyticsMonitorSettings("YOUR_PRODUCT_KEY_HERE");

                 settings.TestMode = true;

                 //Creating IAnalyticsMonitor

                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor(settings);

                 //Start Analytics monitor

                 monitor.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 monitor.Stop();

               }

             }

             </code>

             </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateStorage(System.String)">

            <summary>

            Creates an <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> which stores the data in given folder. This instance can be

            used when creating the monitor instance by assigning it to the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.StorageInterface"/>

            on the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance.

            </summary>

            <remarks>This call will attempt to create the given folder it it does not already exists. If there are no permissions

            or if the folder specifies an invalid folder path the method will raise an exception. </remarks>

            <param name="folder">The path to the folder where the monitor should persist data.</param>

            <returns>An implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface for use on the file system.</returns>

            <exception cref="T:System.InvalidOperationException">If unable to locate or create the specified folder. See inner exception for details.</exception>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateStorage(System.String,System.String)">

            <summary>

            Creates an <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> which stores the data in given folder and with the given identifier. This instance can be

            used when creating the monitor instance by assigning it to the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.StorageInterface"/>

            on the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance. Use this overload to handle e.g. terminal services or shared

            machines where multiple users share the same machine but you need differentiated monitoring by passing e.g. the

            user name as identifier.

            </summary>

            <remarks>This call will attempt to create the given folder it it does not already exists. If there are no permissions

            or if the folder specifies an invalid folder path the method will raise an exception. </remarks>

            <param name="folder">The path to the folder where the monitor should persist data.</param>

            <param name="identifier">The unique identifier to use for differentiating the storage.</param>

            <returns>An implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface for use on the file system.</returns>

            <exception cref="T:System.InvalidOperationException">If unable to locate or create the specified folder. See inner exception for details.</exception>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateStorage(System.IO.IsolatedStorage.IsolatedStorageScope)">

            <summary>

            Creates an <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> implementation that utilizes the IsolatedStorage

            to store files

            </summary>

            <param name="scope">The specific scope to utilize when determining where to store the data files</param>

            <returns>an implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface that utilizes the IsolatedStorage</returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateStorage">

            <summary>

            Creates an <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> implementation that utilizes the IsolatedStorage

            to store files. 

            </summary>

            <returns>an implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface that utilizes the IsolatedStorage</returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateSettings(System.String)">

            <summary>

            Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings"/> instance for customizing the

            creation of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/>. You can customize this instance

            and pass it to the <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)"/> to obtain

            the customized

            </summary>

            <param name="productId">The product ID</param>

            <returns>an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings"/> instance</returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateTraceMonitor">

            <summary>

            Creates a simple <see cref="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor"/> implementation that logs to the standard <see cref="T:System.Diagnostics.Trace"/>

            output. You can assign this instance to the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.LoggingInterface"/> property on the

            <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance to have the internal messages from the monitor written to the Trace output.

            </summary>

            <returns>An implementation of the <see cref="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor"/> that log messages to <see cref="T:System.Diagnostics.Trace"/></returns>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus">

            <summary>

            Class encapsulating the current status of an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance. 

            <remarks>Note that most of these status properties only makes sense if the monitor has been started</remarks>

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.Capabilities">

            <summary>

            Get the capabilities of the current analytics monitor. The <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities"/> instance

            will allow callers to adjust certain call parameters to not violate the limitations

            of the current monitor.

            </summary>

            <seealso cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities"/>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.IsStarted">

            <summary>

            Get whether the monitor is currently started

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.RunTime">

            <summary>

            Get the total runtime for the monitor. Will return <see cref="F:System.TimeSpan.Zero"/> if monitor is not started.

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.CookieId">

            <summary>

            Get the current value of the cookie identifier for the monitor.

            <remarks>Note that this value may be <c>null</c> if the monitor is not started or if no cookie id has been assigned to this device yet.</remarks>

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.Connectivity">

            <summary>

            Get the current connectivity status for the monitor. This value will reflect the current internal

            status of the connectivity of the monitor to the server. 

            <remarks>Note that this status is not a snapshot of general connectivity to the server but merely 

            reflects the state of the last data delivery attempt to the server. Also note that if the monitor

            is configured to not synchronize automatically (using the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.SynchronizeAutomatically"/> property)

            this status is not updated until the monitor has been explicitly forced to synchronize data (using the 

            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync"/> method)</remarks>

            </summary>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor">

            <summary>

            Interface used for outputting log messages internally from

            a constructed <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance. The logging interface can be

            specified on the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings"/> object which passed into the

            <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)"/> call

            </summary>

            <example>The following is an example of creating your custom logging implementation

            and hooking it up:

            <code>

            public class MyConsoleLog : ILogAnalyticsMonitor

            {

              public void LogMessage(string message)

              { 

                 System.Console.WriteLine("MESSAGE: " + message);

              }

              public void LogError(string error)

              {

                 System.Console.WriteLine("ERROR: " + error);

              }

            }

            ...

            AnalyticsMonitorSettings setttings = new AnalyticsMonitorSettings("PRODUCT_KEY_HERE");

            settings.LoggingInterface = new MyConsoleLog();

            IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create(settings);

            ...

            </code></example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor.LogMessage(System.String)">

            <summary>

            Logging a message. This is called for informative messages

            internally in the analytics monitor. These are not error messages

            but messages on specific actions being performed

            </summary>

            <param name="message">describes the action being performed</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor.LogError(System.String)">

            <summary>

            Logging an error message. This is called when an error occurs

            internally in the analytics monitor. The errorMessage will contain

            a human readable error message describing the error

            </summary>

            <param name="errorMessage">describes the error message</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.ArgumentChecker.#ctor">

            <summary>

            Constructor

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.ArgumentChecker.#ctor(EQATEC.Analytics.Monitor.IStatisticsMonitor,EQATEC.Analytics.Monitor.LogAnalyticsMonitorImpl,EQATEC.Analytics.Monitor.Policy.MonitorPolicy)">

            <summary>

            Constructor

            </summary>

            <param name="statisticsMonitor"></param>

            <param name="log">the logging interface</param>

            <param name="policy">the internal settings object</param>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities">

            <summary>

            Exposing the current capabilities of the analytics monitor instance that may influence

            how the data you pass into the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance are handled. 

            </summary>

            <remarks>Note that

            the capabilities may change at runtime after e.g. interaction with the EQATEC Analytics

            servers</remarks>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities.MaxLengthOfExceptionContextMessage">

            <summary>

            Get the maximum allowed size of the context message associated with an exception in a call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String)"/>.

            Longer context messages will be truncated

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities.MaxAllowedBandwidthUsagePerDayInKB">

            <summary>

            Get the maximum allowed bandwidth utilization for the monitor per day measured in kilobytes. This setting can be

            altered before constructing the monitor instance by using the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.DailyNetworkUtilizationInKB"/>

            property

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities.MaxLengthOfFeatureName">

            <summary>

            Get the maximum allowed length of a feature name as used in <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/>, <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/>,

            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> or <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)"/>

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities.MaxNumberOfInstallationProperties">

            <summary>

            Get the maximum number of installation properties stored with a given installation id. You can pass in

            installation properties using <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})"/>.

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities.MaxKeySizeOfInstallationPropertyKey">

            <summary>

            Get the maximum size of an installation property key. Installation properties are specified using <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})"/>. 

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities.MaxStorageSizeInKB">

            <summary>

            Get the maximum size of the data written to storage from the monitor. This size altered before 

            constructing the monitor instance by using the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.MaxStorageSizeInKB"/> 

            property

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities.MaxInstallationIDSize">

            <summary>

            Get the maximum size of the installationid accepted in <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})"/>. Values

            that are too long are truncated

            </summary>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings">

            <summary>

            Interface for the settings used for constructing the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance. Instances

            are preloaded with default settings which can be adjusted before instance is being passed to 

            the <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)"/> method  

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.ProductId">

            <summary>

            Get the product id that will be used for creation of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.Version">

            <summary>

            Specifies the version of the software, that should be used for version checking.

            The default value is implicitly retreived of the current application

            by accessing the calling assembly.

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.LoggingInterface">

             <summary>

             The logging interface used for exposing internal messages

             </summary>

             <remarks>You can provide your own implementation of the <see cref="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor"/> interface in 

             order to receive the internal logging messages from constructed monitors</remarks>

             <example> This sample shows how to use the logging interface.

             <code>

             class MyClass 

             {

               static void Main() 

               {

                 //Creating AnalyticsMonitorSettings

                 AnalyticsMonitorSettings settings = new AnalyticsMonitorSettings("YOUR_PRODUCT_KEY_HERE");

                 settings.LoggingInterface = new MyLogClass();

                 //Creating IAnalyticsMonitor

                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create(settings);

                 //Start Analytics monitor

                 monitor.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 monitor.Stop();

               }

             }

             class MyLogClass : ILogAnalyticsMonitor

             {

               public void LogMessage(string message)

               {

                 Console.WriteLine("Log: " + message);

               }

               public void LogError(string errorMessage)

               {

                 Console.WriteLine("Error: " + errorMessage);

               }

             }

             </code>

             </example>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.StorageInterface">

            <summary>

            The storage interface used internally in the analytics monitor

            for saving and loading state. 

            </summary>

            <remarks>Consider providing your own implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface if

            your application requires special handling when storing data.</remarks>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.StorageSaveInterval">

            <summary>

            The interval with which we autosave the internal statistics. The default

            is one minute. If set to TimeSpan.Zero, no AutoSave is performed

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.ServerUri">

            <summary>

            Override the default uri for the server. For most standard purposes there is no

            need to provide your own uri for the server as the monitor provides a default uri

            which will contact the server correctly

            </summary>

            <remarks>You may require to specify this server uri if the network setup for your

            end users are non-standard. Also be aware that the <see cref="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.UseSSL"/> property is

            is ignored when explicitly specifying the server uri.</remarks>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.TestMode">

            <summary>

             Use this flag to enable the test mode for this installation.

             This might for example allow you to test version announcements

             before relasing it to customers.

            </summary>

             <remarks>The precise behavior for the <see cref="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.TestMode"/> property may change over time but

             is provided to explicitly enable certain test scenarios for developers</remarks>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.SynchronizeAutomatically">

            <summary>

             Use this flag to specify is the monitor automatically should synchronize data 

             to the server or it should only synchronize manually on explicit calls to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync"/>.

             The default value is <see langwork="true"/> as the he monitor will automatically synchronize data to the 

             server without the clients have to call <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync"/>.

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.DailyNetworkUtilizationInKB">

            <summary>

            Explicitly set a limit on the daily network utilization of the monitor. The utilization

            is accumulated based on the size of the payload for both upstream and downstream data and 

            is enforce on a daily basis. 

            </summary>

            <remarks>The monitor will not honor a limit lower than 10 kb since the 

            monitor must be able to contact the server with at least a mimimum of payload. If you do not want the monitor to contact the 

            server you should not call <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/> on the monitor instance.</remarks>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings.MaxStorageSizeInKB">

            <summary>

            Explicitly set a size limit on the data save to persistent storage by the monitor. The size

            is calculated each time the monitor persists to storage and if the size limit is exceeded it

            will attempt to persist less data. 

            </summary>

            <remarks>The monitor will not honor a limit lower than 1 kb since the monitor requires to

            store at least a minimal amount of metadata</remarks>

        </member>