Added the ability to update a sessions activity without submitting an event.

niemyjski · niemyjski · commit d27f368c7905 · 2016-04-28T16:46:53.000-05:00
diff --git a/Source/Extras/Extensions/ExceptionlessExtraConfigurationExtensions.cs b/Source/Extras/Extensions/ExceptionlessExtraConfigurationExtensions.cs
@@ -96,7 +96,7 @@ public static void ReadFromConfigSection(this ExceptionlessConfiguration config)
                 config.ApiKey = section.ApiKey;
             
             if (!String.IsNullOrEmpty(section.ServerUrl))
-                config.ServerUrl = section.ServerUrl;
+                config.ServerUrl = config.HeartbeatServerUrl = section.ServerUrl;
 
             if (section.QueueMaxAge.HasValue)
                 config.QueueMaxAge = section.QueueMaxAge.Value;
@@ -176,7 +176,7 @@ public static void ReadFromAppSettings(this ExceptionlessConfiguration config) {
             
             string serverUrl = ConfigurationManager.AppSettings["Exceptionless:ServerUrl"];
             if (!String.IsNullOrEmpty(serverUrl))
-                config.ServerUrl = serverUrl;
+                config.ServerUrl = config.HeartbeatServerUrl = serverUrl;
         }
 
         /// <summary>
@@ -194,7 +194,7 @@ public static void ReadFromEnvironmentalVariables(this ExceptionlessConfiguratio
             
             string serverUrl = GetEnvironmentalVariable("Exceptionless:ServerUrl");
             if (!String.IsNullOrEmpty(serverUrl))
-                config.ServerUrl = serverUrl;
+                config.ServerUrl = config.HeartbeatServerUrl = serverUrl;
         }
 
         private static string GetEnvironmentalVariable(string name) {
diff --git a/Source/Extras/Submission/SubmissionClient.cs b/Source/Extras/Submission/SubmissionClient.cs
@@ -4,6 +4,7 @@
 using System.Net;
 using System.Runtime.CompilerServices;
 using Exceptionless.Configuration;
+using Exceptionless.Dependency;
 using Exceptionless.Extensions;
 using Exceptionless.Extras.Extensions;
 using Exceptionless.Json.Linq;
@@ -23,7 +24,7 @@ public SubmissionResponse PostEvents(IEnumerable<Event> events, ExceptionlessCon
 
             HttpWebResponse response;
             try {
-                var request = CreateHttpWebRequest(config, "events");
+                var request = CreateHttpWebRequest(config, String.Format("{0}/events", config.GetServiceEndPoint()));
                 response = request.PostJsonAsyncWithCompression(data).Result as HttpWebResponse;
             } catch (AggregateException aex) {
                 var ex = aex.GetInnermostException() as WebException;
@@ -47,7 +48,7 @@ public SubmissionResponse PostUserDescription(string referenceId, UserDescriptio
 
             HttpWebResponse response;
             try {
-                var request = CreateHttpWebRequest(config, String.Format("events/by-ref/{0}/user-description", referenceId));
+                var request = CreateHttpWebRequest(config, String.Format("{0}/events/by-ref/{1}/user-description", config.GetServiceEndPoint(), referenceId));
                 response = request.PostJsonAsyncWithCompression(data).Result as HttpWebResponse;
             } catch (AggregateException aex) {
                 var ex = aex.GetInnermostException() as WebException;
@@ -69,7 +70,7 @@ public SubmissionResponse PostUserDescription(string referenceId, UserDescriptio
         public SettingsResponse GetSettings(ExceptionlessConfiguration config, IJsonSerializer serializer) {
             HttpWebResponse response;
             try {
-                var request = CreateHttpWebRequest(config, "projects/config");
+                var request = CreateHttpWebRequest(config, String.Format("{0}/projects/config", config.GetServiceEndPoint()));
                 response = request.GetJsonAsync().Result as HttpWebResponse;
             } catch (Exception ex) {
                 var message = String.Concat("Unable to retrieve configuration settings. Exception: ", ex.GetMessage());
@@ -86,6 +87,17 @@ public SettingsResponse GetSettings(ExceptionlessConfiguration config, IJsonSeri
             var settings = serializer.Deserialize<ClientConfiguration>(json);
             return new SettingsResponse(true, settings.Settings, settings.Version);
         }
+        
+        public void SendHeartbeat(string sessionIdOrUserId, ExceptionlessConfiguration config) {
+            try {
+                var request = CreateHttpWebRequest(config, String.Format("{0}/events/session/{1}/heartbeat", config.GetHeartbeatServiceEndPoint(), sessionIdOrUserId));
+                request.Timeout = 1;
+                var response = request.GetResponseAsync().Result;
+            } catch (Exception ex) {
+                var log = config.Resolver.GetLog();
+                log.Error(String.Concat("Error submitting heartbeat: ", ex.GetMessage()));
+            }
+        }
 
         private static string GetResponseMessage(HttpWebResponse response) {
             if (response.IsSuccessful())
@@ -105,8 +117,8 @@ private static string GetResponseMessage(HttpWebResponse response) {
             return message;
         }
 
-        protected virtual HttpWebRequest CreateHttpWebRequest(ExceptionlessConfiguration config, string endPoint) {
-            var request = (HttpWebRequest)WebRequest.Create(String.Concat(config.GetServiceEndPoint(), endPoint));
+        protected virtual HttpWebRequest CreateHttpWebRequest(ExceptionlessConfiguration config, string url) {
+            var request = (HttpWebRequest)WebRequest.Create(url);
             request.AddAuthorizationHeader(config);
             request.SetUserAgent(config.UserAgent);
             request.AllowAutoRedirect = true;
diff --git a/Source/Platforms/Log4net/BufferingExceptionlessAppender.cs b/Source/Platforms/Log4net/BufferingExceptionlessAppender.cs
@@ -24,7 +24,7 @@ public override void ActivateOptions() {
                 if (!String.IsNullOrEmpty(ApiKey) && ApiKey != "API_KEY_HERE")
                     config.ApiKey = ApiKey;
                 if (!String.IsNullOrEmpty(ServerUrl))
-                    config.ServerUrl = ServerUrl;
+                    config.ServerUrl = config.HeartbeatServerUrl = ServerUrl;
                 config.UseInMemoryStorage();
             });
         }
diff --git a/Source/Platforms/Log4net/ExceptionlessAppender.cs b/Source/Platforms/Log4net/ExceptionlessAppender.cs
@@ -17,7 +17,7 @@ public override void ActivateOptions() {
                 if (!String.IsNullOrEmpty(ApiKey) && ApiKey != "API_KEY_HERE")
                     config.ApiKey = ApiKey;
                 if (!String.IsNullOrEmpty(ServerUrl))
-                    config.ServerUrl = ServerUrl;
+                    config.ServerUrl = config.HeartbeatServerUrl = ServerUrl;
                 config.UseInMemoryStorage();
             });
         }
diff --git a/Source/Platforms/NLog/ExceptionlessTarget.cs b/Source/Platforms/NLog/ExceptionlessTarget.cs
@@ -27,7 +27,7 @@ protected override void InitializeTarget() {
                     if (!String.IsNullOrEmpty(ApiKey) && ApiKey != "API_KEY_HERE")
                         config.ApiKey = ApiKey;
                     if (!String.IsNullOrEmpty(ServerUrl))
-                        config.ServerUrl = ServerUrl;
+                        config.ServerUrl = config.HeartbeatServerUrl = ServerUrl;
                     config.UseInMemoryStorage();
                 });
         }
diff --git a/Source/Samples/SampleConsole/Program.cs b/Source/Samples/SampleConsole/Program.cs
@@ -86,9 +86,7 @@ private static void Main() {
                 } else if (keyInfo.Key == ConsoleKey.D5) {
                     ExceptionlessClient.Default.Configuration.UseSessions(false, null, true);
                     ExceptionlessClient.Default.SubmitSessionStart();
-                } else if (keyInfo.Key == ConsoleKey.D6)
-                    ExceptionlessClient.Default.SubmitSessionHeartbeat();
-                else if (keyInfo.Key == ConsoleKey.D7)
+                } else if (keyInfo.Key == ConsoleKey.D7)
                     ExceptionlessClient.Default.SubmitSessionEnd();
                 else if (keyInfo.Key == ConsoleKey.D8)
                     ExceptionlessClient.Default.Configuration.SetUserIdentity(Guid.NewGuid().ToString("N"));
diff --git a/Source/Samples/SampleConsole/Submission/InMemorySubmissionClient.cs b/Source/Samples/SampleConsole/Submission/InMemorySubmissionClient.cs
@@ -4,33 +4,34 @@
 using Exceptionless.Models.Data;
 using Exceptionless.Submission;
 
-namespace Exceptionless.SampleConsole
-{
-    public class InMemorySubmissionClient: ISubmissionClient {
-        private static readonly Dictionary<string, object> _eventRepository = new Dictionary<string, object>();
-        private static readonly Dictionary<string, object> _userDescriptionRepository = new Dictionary<string, object>();
+namespace Exceptionless.SampleConsole {
+    public class InMemorySubmissionClient : ISubmissionClient {
+        private readonly Dictionary<string, object> _eventContainer = new Dictionary<string, object>();
+        private readonly Dictionary<string, object> _userDescriptionContainer = new Dictionary<string, object>();
+        private readonly Dictionary<string, DateTime> _heartbeatContainer = new Dictionary<string, DateTime>();
 
         public SubmissionResponse PostEvents(IEnumerable<Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) {
-            foreach (Event e in events)
-            {
+            foreach (Event e in events) {
                 string data = serializer.Serialize(e);
-                string referenceId = !string.IsNullOrWhiteSpace(e.ReferenceId)
-                    ? e.ReferenceId
-                    : Guid.NewGuid().ToString("D");
-                _eventRepository[referenceId] = data;
+                string referenceId = !string.IsNullOrWhiteSpace(e.ReferenceId) ? e.ReferenceId : Guid.NewGuid().ToString("D");
+                _eventContainer[referenceId] = data;
             }
-            return new SubmissionResponse(200);
 
+            return new SubmissionResponse(200);
         }
 
         public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) {
             string data = serializer.Serialize(description);
-            _userDescriptionRepository[referenceId] = data;
+            _userDescriptionContainer[referenceId] = data;
             return new SubmissionResponse(200);
         }
 
         public SettingsResponse GetSettings(ExceptionlessConfiguration config, IJsonSerializer serializer) {
             return new SettingsResponse(true);
         }
+
+        public void SendHeartbeat(string sessionIdOrUserId, ExceptionlessConfiguration config) {
+            _heartbeatContainer[sessionIdOrUserId] = DateTime.UtcNow;
+        }
     }
-}
+}
diff --git a/Source/Shared/Configuration/ExceptionlessConfiguration.cs b/Source/Shared/Configuration/ExceptionlessConfiguration.cs
@@ -11,12 +11,14 @@
 namespace Exceptionless {
     public class ExceptionlessConfiguration {
         private const string DEFAULT_SERVER_URL = "https://collector.exceptionless.io";
+        private const string DEFAULT_HEARTBEAT_SERVER_URL = "https://heartbeat.exceptionless.io";
         private const string DEFAULT_USER_AGENT = "exceptionless/" + ThisAssembly.AssemblyFileVersion;
         private const int DEFAULT_SUBMISSION_BATCH_SIZE = 50;
 
         private readonly IDependencyResolver _resolver;
         private bool _configLocked;
         private string _apiKey;
+        private string _heartbeatServerUrl;
         private string _serverUrl;
         private int _submissionBatchSize;
         private ValidationResult _validationResult;
@@ -28,6 +30,7 @@ public ExceptionlessConfiguration(IDependencyResolver resolver) {
                 throw new ArgumentNullException("resolver");
 
             ServerUrl = DEFAULT_SERVER_URL;
+            HeartbeatServerUrl = DEFAULT_HEARTBEAT_SERVER_URL;
             UserAgent = DEFAULT_USER_AGENT;
             SubmissionBatchSize = DEFAULT_SUBMISSION_BATCH_SIZE;
             Enabled = true;
@@ -72,6 +75,23 @@ public string ServerUrl {
             }
         }
 
+        /// <summary>
+        /// The server url that all events will be sent to.
+        /// </summary>
+        public string HeartbeatServerUrl {
+            get { return _heartbeatServerUrl; }
+            set {
+                if (_heartbeatServerUrl == value)
+                    return;
+
+                if (_configLocked)
+                    throw new ArgumentException("HeartbeatServerUrl can't be changed after the client has been initialized.");
+
+                _validationResult = null;
+                _heartbeatServerUrl = value;
+            }
+        }
+
         /// <summary>
         /// Used to identify the client that sent the events to the server.
         /// </summary>
@@ -358,6 +378,9 @@ public ValidationResult Validate() {
             if (String.IsNullOrEmpty(ServerUrl))
                 result.Messages.Add("ServerUrl is not set.");
 
+            if (String.IsNullOrEmpty(HeartbeatServerUrl))
+                result.Messages.Add("HeartbeatServerUrl is not set.");
+
             return result;
         }
 
diff --git a/Source/Shared/Extensions/ClientExtensions.cs b/Source/Shared/Extensions/ClientExtensions.cs
@@ -1,4 +1,6 @@
 ﻿using System;
+using System.Threading.Tasks;
+using Exceptionless.Dependency;
 using Exceptionless.Logging;
 using Exceptionless.Models;
 
@@ -208,20 +210,17 @@ public static void SubmitSessionEnd(this ExceptionlessClient client) {
             client.CreateSessionEnd().Submit();
         }
 
-        /// <summary>
-        /// Creates a session heartbeat event.
-        /// </summary>
-        /// <param name="client">The client instance.</param>
-        public static EventBuilder CreateSessionHeartbeat(this ExceptionlessClient client) {
-            return client.CreateEvent().SetType(Event.KnownTypes.SessionHeartbeat);
-        }
-
         /// <summary>
         /// Submits a session heartbeat event.
         /// </summary>
         /// <param name="client">The client instance.</param>
-        public static void SubmitSessionHeartbeat(this ExceptionlessClient client) {
-            client.CreateSessionHeartbeat().Submit();
+        /// <param name="sessionIdOrUserId">The session id or user id.</param>
+        public static void SubmitSessionHeartbeat(this ExceptionlessClient client, string sessionIdOrUserId) {
+            if (String.IsNullOrWhiteSpace(sessionIdOrUserId))
+                return;
+
+            var submissionClient = client.Configuration.Resolver.GetSubmissionClient();
+            Task.Factory.StartNew(() => submissionClient.SendHeartbeat(sessionIdOrUserId, client.Configuration));
         }
     }
 }
diff --git a/Source/Shared/Extensions/EventExtensions.cs b/Source/Shared/Extensions/EventExtensions.cs
@@ -68,14 +68,7 @@ public static bool IsLog(this Event ev) {
         public static bool IsFeatureUsage(this Event ev) {
             return ev.Type == Event.KnownTypes.FeatureUsage;
         }
-
-        /// <summary>
-        /// Returns true if the event type is session heartbeat.
-        /// </summary>
-        public static bool IsSessionHeartbeat(this Event ev) {
-            return ev.Type == Event.KnownTypes.SessionHeartbeat;
-        }
-
+        
         /// <summary>
         /// Returns true if the event type is session start.
         /// </summary>
diff --git a/Source/Shared/Extensions/ExceptionlessConfigurationExtensions.cs b/Source/Shared/Extensions/ExceptionlessConfigurationExtensions.cs
@@ -92,7 +92,7 @@ public static string GetInstallId(this ExceptionlessConfiguration config) {
         /// </summary>
         /// <param name="config">Exceptionless configuration</param>
         /// <param name="sendHeartbeats">Controls whether heartbeat events are sent on an interval.</param>
-        /// <param name="heartbeatInterval">The interval at which heartbeats are sent after the last sent event. The default is 5 minutes.</param>
+        /// <param name="heartbeatInterval">The interval at which heartbeats are sent after the last sent event. The default is 1 minutes.</param>
         /// <param name="useSessionIdManagement">Allows you to manually control the session id. This is only recommended for single user desktop environments.</param>
         public static void UseSessions(this ExceptionlessConfiguration config, bool sendHeartbeats = true, TimeSpan? heartbeatInterval = null, bool useSessionIdManagement = false) {
             config.SessionsEnabled = true;
@@ -173,7 +173,7 @@ public static void ReadFromAttributes(this ExceptionlessConfiguration config, IC
                     if (!String.IsNullOrEmpty(attr.ApiKey) && attr.ApiKey != "API_KEY_HERE")
                         config.ApiKey = attr.ApiKey;
                     if (!String.IsNullOrEmpty(attr.ServerUrl))
-                        config.ServerUrl = attr.ServerUrl;
+                        config.ServerUrl = config.HeartbeatServerUrl = attr.ServerUrl;
 
                     break;
                 }
@@ -197,7 +197,18 @@ namespace Exceptionless.Extensions {
     public static class ExceptionlessConfigurationExtensions {
         public static Uri GetServiceEndPoint(this ExceptionlessConfiguration config) {
             var builder = new UriBuilder(config.ServerUrl);
-            builder.Path += builder.Path.EndsWith("/") ? "api/v2/" : "/api/v2/";
+            builder.Path += builder.Path.EndsWith("/") ? "api/v2" : "/api/v2";
+
+            // EnableSSL
+            if (builder.Scheme == "https" && builder.Port == 80 && !builder.Host.Contains("local"))
+                builder.Port = 443;
+
+            return builder.Uri;
+        }
+        
+        public static Uri GetHeartbeatServiceEndPoint(this ExceptionlessConfiguration config) {
+            var builder = new UriBuilder(config.HeartbeatServerUrl);
+            builder.Path += builder.Path.EndsWith("/") ? "api/v2" : "/api/v2";
 
             // EnableSSL
             if (builder.Scheme == "https" && builder.Port == 80 && !builder.Host.Contains("local"))
diff --git a/Source/Shared/Models/Client/Event.cs b/Source/Shared/Models/Client/Event.cs
@@ -93,7 +93,6 @@ public static class KnownTypes {
             public const string NotFound = "404";
             public const string Session = "session";
             public const string SessionEnd = "sessionend";
-            public const string SessionHeartbeat = "heartbeat";
         }
 
         public static class KnownTags {
diff --git a/Source/Shared/Plugins/Default/1000_CancelSessionsWithNoUserPlugin.cs b/Source/Shared/Plugins/Default/1000_CancelSessionsWithNoUserPlugin.cs
@@ -5,7 +5,7 @@ namespace Exceptionless.Plugins.Default {
     [Priority(1000)]
     public class CancelSessionsWithNoUserPlugin : IEventPlugin {
         public void Run(EventPluginContext context) {
-            if (!context.Event.IsSessionStart() && !context.Event.IsSessionEnd() && !context.Event.IsSessionHeartbeat())
+            if (!context.Event.IsSessionStart() && !context.Event.IsSessionEnd())
                 return;
 
             var user = context.Event.GetUserIdentity(context.Client.Configuration.Resolver.GetJsonSerializer());
diff --git a/Source/Shared/Plugins/Default/100_HeartbeatPlugin.cs b/Source/Shared/Plugins/Default/100_HeartbeatPlugin.cs
@@ -12,15 +12,12 @@ public class HeartbeatPlugin : IEventPlugin, IDisposable {
         /// <summary>
         /// Controls whether session heartbeats are sent.
         /// </summary>
-        /// <param name="interval">The interval at which heartbeats are sent after the last sent event. The default is 5 minutes.</param>
+        /// <param name="interval">The interval at which heartbeats are sent after the last sent event. The default is 1 minutes.</param>
         public HeartbeatPlugin(TimeSpan? interval = null) {
-            _interval = interval.HasValue && interval.Value.Ticks > 0 ? interval.Value : TimeSpan.FromMinutes(5);
+            _interval = interval.HasValue && interval.Value.Ticks > 0 ? interval.Value : TimeSpan.FromMinutes(1);
         }
 
         public void Run(EventPluginContext context) {
-            if (context.Event.IsSessionHeartbeat())
-                return;
-            
             if (context.Event.IsSessionEnd()) {
                 if (_heartbeat != null) {
                     _heartbeat.Dispose();
@@ -74,7 +71,7 @@ public void DelayNext() {
         }
 
         private void SendHeartbeat(object state) {
-            _client.CreateSessionHeartbeat().SetUserIdentity(User).Submit();
+            _client.SubmitSessionHeartbeat(User.Identity);
         }
 
         public void Dispose() {
diff --git a/Source/Shared/Submission/DefaultSubmissionClient.cs b/Source/Shared/Submission/DefaultSubmissionClient.cs
diff --git a/Source/Shared/Submission/ISubmissionClient.cs b/Source/Shared/Submission/ISubmissionClient.cs
diff --git a/Source/Tests/ExceptionlessClientTests.cs b/Source/Tests/ExceptionlessClientTests.cs
diff --git a/Source/Tests/Plugins/PluginTests.cs b/Source/Tests/Plugins/PluginTests.cs
diff --git a/Source/Tests/Utility/InMemorySubmissionClient.cs b/Source/Tests/Utility/InMemorySubmissionClient.cs
diff --git a/appveyor.yml b/appveyor.yml

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public override void ActivateOptions() {`
`24`	`24`	`if (!String.IsNullOrEmpty(ApiKey) && ApiKey != "API_KEY_HERE")`
`25`	`25`	`config.ApiKey = ApiKey;`
`26`	`26`	`if (!String.IsNullOrEmpty(ServerUrl))`
`27`		`- config.ServerUrl = ServerUrl;`
	`27`	`+ config.ServerUrl = config.HeartbeatServerUrl = ServerUrl;`
`28`	`28`	`config.UseInMemoryStorage();`
`29`	`29`	`});`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public override void ActivateOptions() {`
`17`	`17`	`if (!String.IsNullOrEmpty(ApiKey) && ApiKey != "API_KEY_HERE")`
`18`	`18`	`config.ApiKey = ApiKey;`
`19`	`19`	`if (!String.IsNullOrEmpty(ServerUrl))`
`20`		`- config.ServerUrl = ServerUrl;`
	`20`	`+ config.ServerUrl = config.HeartbeatServerUrl = ServerUrl;`
`21`	`21`	`config.UseInMemoryStorage();`
`22`	`22`	`});`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ protected override void InitializeTarget() {`
`27`	`27`	`if (!String.IsNullOrEmpty(ApiKey) && ApiKey != "API_KEY_HERE")`
`28`	`28`	`config.ApiKey = ApiKey;`
`29`	`29`	`if (!String.IsNullOrEmpty(ServerUrl))`
`30`		`- config.ServerUrl = ServerUrl;`
	`30`	`+ config.ServerUrl = config.HeartbeatServerUrl = ServerUrl;`
`31`	`31`	`config.UseInMemoryStorage();`
`32`	`32`	`});`
`33`	`33`	`}`