public static void UpdateSettings(ExceptionlessConfiguration config) { if (String.IsNullOrEmpty(config.ApiKey) || String.Equals(config.ApiKey, "API_KEY_HERE", StringComparison.OrdinalIgnoreCase)) { config.Resolver.GetLog().Error(typeof(SettingsManager), "Unable to update settings: ApiKey is not set."); return; } var serializer = config.Resolver.GetJsonSerializer(); var client = config.Resolver.GetSubmissionClient(); var response = client.GetSettings(config, serializer); if (!response.Success || response.Settings == null) return; var savedServerSettings = GetSavedServerSettings(config); config.Settings.Apply(response.Settings); // TODO: Store snapshot of settings after reading from config and attributes and use that to revert to defaults. // Remove any existing server settings that are not in the new server settings. foreach (string key in savedServerSettings.Keys.Except(response.Settings.Keys)) { if (config.Settings.ContainsKey(key)) config.Settings.Remove(key); } var persistedClientData = config.Resolver.Resolve<PersistedDictionary>(); persistedClientData[String.Concat(config.GetQueueName(), "-ServerConfigVersion")] = response.SettingsVersion.ToString(); var fileStorage = config.Resolver.GetFileStorage(); fileStorage.SaveObject(GetConfigPath(config), response.Settings); }
public static void AddDefaultPlugins(ExceptionlessConfiguration config) { config.AddPlugin<ConfigurationDefaultsPlugin>(); config.AddPlugin<SimpleErrorPlugin>(); config.AddPlugin<DuplicateCheckerPlugin>(); config.AddPlugin<EnvironmentInfoPlugin>(); config.AddPlugin<SubmissionMethodPlugin>(); }
public SettingsResponse GetSettings(ExceptionlessConfiguration config, int version, IJsonSerializer serializer) { if (!config.IsValid) return new SettingsResponse(false, message: "Invalid client configuration settings."); string url = String.Format("{0}/projects/config?v={1}", GetServiceEndPoint(config), version); HttpResponseMessage response; try { _client.Value.AddAuthorizationHeader(config.ApiKey); response = _client.Value.GetAsync(url).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (Exception ex) { var message = String.Concat("Unable to retrieve configuration settings. Exception: ", ex.GetMessage()); return new SettingsResponse(false, message: message); } if (response != null && response.StatusCode == HttpStatusCode.NotModified) return new SettingsResponse(false, message: "Settings have not been modified."); if (response == null || response.StatusCode != HttpStatusCode.OK) return new SettingsResponse(false, message: String.Concat("Unable to retrieve configuration settings: ", GetResponseMessage(response))); var json = GetResponseText(response); if (String.IsNullOrWhiteSpace(json)) return new SettingsResponse(false, message: "Invalid configuration settings."); var settings = serializer.Deserialize<ClientConfiguration>(json); return new SettingsResponse(true, settings.Settings, settings.Version); }
public static void CheckVersion(int version, ExceptionlessConfiguration config) { var persistedClientData = config.Resolver.Resolve<PersistedDictionary>(); if (version <= persistedClientData.GetInt32(String.Concat(config.GetQueueName(), "-ServerConfigVersion"), -1)) return; UpdateSettings(config); }
public void CanUpdateSettingsFromServer() { var config = new ExceptionlessConfiguration(DependencyResolver.Default); config.ApiKey = "e3d51ea621464280bbcb79c11fd6483e"; config.Settings["LocalSetting"] = "1"; config.Settings["LocalSettingToOverride"] = "1"; var submissionClient = new Mock<ISubmissionClient>(); submissionClient.Setup(m => m.Submit(It.IsAny<IEnumerable<Event>>(), config, It.IsAny<IJsonSerializer>())) .Callback(() => SettingsManager.CheckVersion(1, config)) .Returns(() => new SubmissionResponse(202, "Accepted")); submissionClient.Setup(m => m.GetSettings(config, It.IsAny<IJsonSerializer>())) .Returns(() => new SettingsResponse(true, new SettingsDictionary { { "Test", "Test" }, { "LocalSettingToOverride", "2" } }, 1)); config.Resolver.Register<ISubmissionClient>(submissionClient.Object); var client = new ExceptionlessClient(config); Assert.Equal(2, client.Configuration.Settings.Count); Assert.False(client.Configuration.Settings.ContainsKey("Test")); Assert.Equal("1", client.Configuration.Settings["LocalSettingToOverride"]); client.SubmitEvent(new Event { Type = "Log", Message = "Test" }); client.ProcessQueue(); Assert.True(client.Configuration.Settings.ContainsKey("Test")); Assert.Equal("2", client.Configuration.Settings["LocalSettingToOverride"]); Assert.Equal(3, client.Configuration.Settings.Count); var storage = config.Resolver.GetFileStorage() as InMemoryFileStorage; Assert.True(storage.Exists(config.GetQueueName() + "\\server-settings.json")); config.Settings.Clear(); config.ApplySavedServerSettings(); Assert.True(client.Configuration.Settings.ContainsKey("Test")); Assert.Equal("2", client.Configuration.Settings["LocalSettingToOverride"]); Assert.Equal(2, client.Configuration.Settings.Count); }
public static void CheckVersion(int version, ExceptionlessConfiguration config) { int currentVersion = GetVersion(config); if (version <= currentVersion) return; UpdateSettings(config, currentVersion); }
public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) { if (!config.IsValid) return new SubmissionResponse(500, message: "Invalid client configuration settings."); string data = serializer.Serialize(description); string url = String.Format("{0}/events/by-ref/{1}/user-description", GetServiceEndPoint(config), referenceId); HttpResponseMessage response; try { HttpContent content = new StringContent(data, Encoding.UTF8, "application/json"); // don't compress data smaller than 4kb if (data.Length > 1024 * 4) content = new GzipContent(content); _client.Value.AddAuthorizationHeader(config.ApiKey); response = _client.Value.PostAsync(url, content).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (Exception ex) { return new SubmissionResponse(500, message: ex.Message); } int settingsVersion; if (Int32.TryParse(GetSettingsVersionHeader(response.Headers), out settingsVersion)) SettingsManager.CheckVersion(settingsVersion, config); return new SubmissionResponse((int)response.StatusCode, GetResponseMessage(response)); }
public static void UpdateSettings(ExceptionlessConfiguration config, int? version = null) { if (config == null || !config.IsValid || !config.Enabled) return; try { if (!version.HasValue || version < 0) version = GetVersion(config); var serializer = config.Resolver.GetJsonSerializer(); var client = config.Resolver.GetSubmissionClient(); var response = client.GetSettings(config, version.Value, serializer); if (!response.Success || response.Settings == null) return; var savedServerSettings = GetSavedServerSettings(config); config.Settings.Apply(response.Settings); // TODO: Store snapshot of settings after reading from config and attributes and use that to revert to defaults. // Remove any existing server settings that are not in the new server settings. foreach (string key in savedServerSettings.Keys.Except(response.Settings.Keys)) { if (config.Settings.ContainsKey(key)) config.Settings.Remove(key); } var persistedClientData = config.Resolver.Resolve<PersistedDictionary>(); persistedClientData[String.Concat(config.GetQueueName(), "-ServerConfigVersion")] = response.SettingsVersion.ToString(); var fileStorage = config.Resolver.GetFileStorage(); fileStorage.SaveObject(GetConfigPath(config), response.Settings); } catch (Exception ex) { config.Resolver.GetLog().Error(typeof(SettingsManager), ex, "Error occurred updating settings."); } }
public static void AddAuthorizationHeader(this WebRequest request, ExceptionlessConfiguration configuration) { var authorizationHeader = new AuthorizationHeader { Scheme = ExceptionlessHeaders.Bearer, ParameterText = configuration.ApiKey }; request.Headers[HttpRequestHeader.Authorization] = authorizationHeader.ToString(); }
public SubmissionResponse PostEvents(IEnumerable<Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) { foreach (Event e in events) { string data = serializer.Serialize(e); string referenceId = !string.IsNullOrWhiteSpace(e.ReferenceId) ? e.ReferenceId : Guid.NewGuid().ToString("D"); _eventContainer[referenceId] = data; } return new SubmissionResponse(200); }
public static void AddDefaultPlugins(ExceptionlessConfiguration config) { config.AddPlugin<ConfigurationDefaultsPlugin>(); config.AddPlugin<HandleAggregateExceptionsPlugin>(); config.AddPlugin<SimpleErrorPlugin>(); config.AddPlugin<DuplicateCheckerPlugin>(); config.AddPlugin<EnvironmentInfoPlugin>(); config.AddPlugin<SubmissionMethodPlugin>(); config.AddPlugin<CancelSessionsWithNoUserPlugin>(); }
public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) { var ev = Events.FirstOrDefault(e => e.ReferenceId == referenceId); if (ev == null) return new SubmissionResponse(404, "Not Found"); ev.Data[Event.KnownDataKeys.UserDescription] = description; return new SubmissionResponse(200, "OK"); }
public static void ApplySavedServerSettings(ExceptionlessConfiguration config) { if (String.IsNullOrEmpty(config.ApiKey) || String.Equals(config.ApiKey, "API_KEY_HERE", StringComparison.OrdinalIgnoreCase)) { config.Resolver.GetLog().Error(typeof(SettingsManager), "Unable to apply saved server settings: ApiKey is not set."); return; } var savedServerSettings = GetSavedServerSettings(config); config.Settings.Apply(savedServerSettings); }
public static RequestInfo Collect(HttpContextBase context, ExceptionlessConfiguration config) { if (context == null) return null; var info = new RequestInfo { HttpMethod = context.Request.HttpMethod, UserAgent = context.Request.UserAgent, Path = String.IsNullOrEmpty(context.Request.Path) ? "/" : context.Request.Path }; try { info.ClientIpAddress = context.Request.UserHostAddress; } catch (ArgumentException ex) { config.Resolver.GetLog().Error(ex, "An error occurred while setting the Client Ip Address."); } try { info.IsSecure = context.Request.IsSecureConnection; } catch (ArgumentException ex) { config.Resolver.GetLog().Error(ex, "An error occurred while setting Is Secure Connection."); } if (context.Request.Url != null) info.Host = context.Request.Url.Host; if (context.Request.UrlReferrer != null) info.Referrer = context.Request.UrlReferrer.ToString(); if (context.Request.Url != null) info.Port = context.Request.Url.Port; info.Cookies = context.Request.Cookies.ToDictionary(config.DataExclusions); if (context.Request.Form.Count > 0) info.PostData = context.Request.Form.ToDictionary(config.DataExclusions); else if (context.Request.ContentLength > 0 && context.Request.ContentLength < 1024 * 4) { try { context.Request.InputStream.Position = 0; using (var inputStream = new StreamReader(context.Request.InputStream)) info.PostData = inputStream.ReadToEnd(); } catch (Exception ex) { info.PostData = "Error retrieving POST data: " + ex.Message; } } else if (context.Request.ContentLength > 0) { string value = Math.Round(context.Request.ContentLength / 1024m, 0).ToString("N0"); info.PostData = String.Format("Data is too large ({0}) to be included.", value + "kb"); } try { info.QueryString = context.Request.QueryString.ToDictionary(config.DataExclusions); } catch (Exception ex) { config.Resolver.GetLog().Error(ex, "An error occurred while getting the cookies"); } return info; }
/// <summary> /// Adds the current request info as extended data to the event. /// </summary> /// <param name="ev">The event model.</param> /// <param name="context">The http action context to gather information from.</param> /// <param name="config">The config.</param> public static Event AddHttpRequestInfo(this Event ev, HttpActionContext context, ExceptionlessConfiguration config = null) { if (context == null) return ev; if (config == null) config = ExceptionlessClient.Default.Configuration; ev.AddRequestInfo(context.GetRequestInfo(config)); return ev; }
public DefaultEventQueue(ExceptionlessConfiguration config, IExceptionlessLog log, ISubmissionClient client, IObjectStorage objectStorage, IJsonSerializer serializer, TimeSpan? processQueueInterval, TimeSpan? queueStartDelay) { _log = log; _config = config; _client = client; _storage = objectStorage; _serializer = serializer; if (processQueueInterval.HasValue) _processQueueInterval = processQueueInterval.Value; _queueTimer = new Timer(OnProcessQueue, null, queueStartDelay ?? TimeSpan.FromSeconds(2), _processQueueInterval); }
public static void CheckVersion(int version, ExceptionlessConfiguration config) { if (String.IsNullOrEmpty(config.ApiKey) || String.Equals(config.ApiKey, "API_KEY_HERE", StringComparison.OrdinalIgnoreCase)) { config.Resolver.GetLog().Error(typeof(SettingsManager), "Unable to check version: ApiKey is not set."); return; } var persistedClientData = config.Resolver.Resolve<PersistedDictionary>(); if (version <= persistedClientData.GetInt32(String.Concat(config.GetQueueName(), "-ServerConfigVersion"), -1)) return; UpdateSettings(config); }
public static void SetUserAgent(this HttpWebRequest request, ExceptionlessConfiguration configuration) { if (_userAgentProperty.Value != null) { try { _userAgentProperty.Value.SetValue(request, configuration.UserAgent, null); return; } catch (Exception ex) { configuration.Resolver.GetLog().Error(ex, "Error occurred setting the user agent."); } } request.Headers[ExceptionlessHeaders.Client] = configuration.UserAgent; }
public void CanReadFromAttributes() { var config = new ExceptionlessConfiguration(DependencyResolver.CreateDefault()); Assert.Null(config.ApiKey); Assert.Equal("https://collector.exceptionless.io", config.ServerUrl); Assert.Equal(0, config.Settings.Count); config.ReadFromAttributes(typeof(ConfigurationTests).Assembly); Assert.Equal("LhhP1C9gijpSKCslHHCvwdSIz298twx271n1l6xw", config.ApiKey); Assert.Equal("http://localhost:45000", config.ServerUrl); Assert.Equal(1, config.Settings.Count); Assert.Equal("configuration", config.Settings["testing"]); }
public SubmissionResponse PostEvents(IEnumerable<Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) { var data = events.ToList(); data.ForEach(e => { if (e.Date == DateTimeOffset.MinValue) e.Date = DateTimeOffset.Now; if (String.IsNullOrEmpty(e.Type)) e.Type = Event.KnownTypes.Log; }); Events.AddRange(data); return new SubmissionResponse(202, "Accepted"); }
public void GetSettingsAsync() { using (WebApp.Start(Settings.Current.BaseURL, AppBuilder.Build)) { var configuration = ExceptionlessConfiguration.CreateDefault(); var serializer = new DefaultJsonSerializer(); var client = new DefaultSubmissionClient(); var response = client.GetSettings(configuration, serializer); Assert.True(response.Success, response.Message); Assert.NotEqual(-1, response.SettingsVersion); Assert.NotNull(response.Settings); Assert.Null(response.Message); } }
public void CanReadFromAttributes() { var config = new ExceptionlessConfiguration(DependencyResolver.CreateDefault()); Assert.Null(config.ApiKey); Assert.Equal("https://collector.exceptionless.io", config.ServerUrl); Assert.Empty(config.Settings); config.ReadFromAttributes(typeof(ConfigurationTests).GetTypeInfo().Assembly); Assert.Equal("LhhP1C9gijpSKCslHHCvwdSIz298twx271n1l6xw", config.ApiKey); Assert.Equal("http://localhost:45000", config.ServerUrl); Assert.Single(config.Settings); Assert.Equal("configuration", config.Settings["testing"]); }
public DefaultEventQueue(ExceptionlessConfiguration config, IExceptionlessLog log, ISubmissionClient client, IFileStorage fileStorage, IJsonSerializer serializer, TimeSpan?processQueueInterval, TimeSpan?queueStartDelay) { _log = log; _config = config; _client = client; _storage = fileStorage; _serializer = serializer; if (processQueueInterval.HasValue) { _processQueueInterval = processQueueInterval.Value; } _queueTimer = new Timer(OnProcessQueue, null, queueStartDelay ?? TimeSpan.FromSeconds(10), _processQueueInterval); }
private Uri GetHeartbeatServiceEndPoint(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")) { builder.Port = 443; } return(builder.Uri); }
public static void ApplySavedServerSettings(ExceptionlessConfiguration config) { string configPath = GetConfigPath(config); var fileStorage = config.Resolver.GetFileStorage(); if (!fileStorage.Exists(configPath)) return; try { var serializer = config.Resolver.GetJsonSerializer(); var savedServerSettings = fileStorage.GetObject<SettingsDictionary>(configPath, serializer); config.Settings.Apply(savedServerSettings); } catch (Exception ex) { config.Resolver.GetLog().FormattedError(typeof(SettingsManager), ex, "Unable to read and apply saved server settings: {0}", ex.Message); } }
public void CanReadFromAttributes() { var config = new ExceptionlessConfiguration(DependencyResolver.CreateDefault()); Assert.Null(config.ApiKey); Assert.Equal("https://collector.exceptionless.com", config.ServerUrl); Assert.True(config.EnableSSL); Assert.Equal(0, config.Settings.Count); config.ReadFromAttributes(typeof(ConfigurationTests).Assembly); Assert.Equal("e3d51ea621464280bbcb79c11fd6483e", config.ApiKey); Assert.Equal("http://localhost:45000", config.ServerUrl); Assert.False(config.EnableSSL); Assert.Equal(1, config.Settings.Count); Assert.Equal("configuration", config.Settings["testing"]); }
public static Uri GetServiceEndPoint(this ExceptionlessConfiguration config) { var builder = new UriBuilder(config.ServerUrl); builder.Path += builder.Path.EndsWith("/") ? "api/v2/" : "/api/v2/"; // EnableSSL if (config.EnableSSL && builder.Port == 80 && !builder.Host.Contains("local")) { builder.Port = 443; builder.Scheme = "https"; } return(builder.Uri); }
private HttpWebRequest CreateHttpWebRequest(ExceptionlessConfiguration config, string endPoint) { var request = (HttpWebRequest)WebRequest.Create(String.Concat(config.GetServiceEndPoint(), endPoint)); request.AddAuthorizationHeader(config); request.SetUserAgent(config.UserAgent); request.AllowAutoRedirect = true; request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.None; try { request.UseDefaultCredentials = true; // if (Credentials != null) // request.Credentials = Credentials; } catch (Exception) {} return request; }
public static RequestInfo Collect(NancyContext context, ExceptionlessConfiguration config) { if (context == null) { return(null); } var info = new RequestInfo { HttpMethod = context.Request.Method }; if (config.IncludeIpAddress) { info.ClientIpAddress = context.Request.UserHostAddress; } if (!String.IsNullOrWhiteSpace(context.Request.Headers.UserAgent)) { info.UserAgent = context.Request.Headers.UserAgent; } if (context.Request.Url != null) { info.Host = context.Request.Url.HostName; info.IsSecure = context.Request.Url.IsSecure; info.Path = context.Request.Url.BasePath + context.Request.Url.Path; info.Port = context.Request.Url.Port.GetValueOrDefault(info.IsSecure ? 443 : 80); } if (!String.IsNullOrWhiteSpace(context.Request.Headers.Referrer)) { info.Referrer = context.Request.Headers.Referrer; } var exclusionsArray = config.DataExclusions as string[] ?? config.DataExclusions.ToArray(); if (config.IncludeCookies) { info.Cookies = context.Request.Cookies.ToDictionary(exclusionsArray); } if (config.IncludeQueryString && context.Request.Url != null && !String.IsNullOrWhiteSpace(context.Request.Url.Query)) { info.QueryString = HttpUtility.ParseQueryString(context.Request.Url.Query).ToDictionary(exclusionsArray); } return(info); }
public static RequestInfo Collect(HttpActionContext context, ExceptionlessConfiguration config) { if (context == null) { return(null); } var info = new RequestInfo { HttpMethod = context.Request.Method.Method }; if (config.IncludeIpAddress) { info.ClientIpAddress = context.Request.GetClientIpAddress(); } if (context.Request.Headers.UserAgent != null) { info.UserAgent = context.Request.Headers.UserAgent.ToString(); } if (context.Request.RequestUri != null) { info.Host = context.Request.RequestUri.Host; info.IsSecure = context.Request.RequestUri.Scheme == "https"; info.Path = String.IsNullOrEmpty(context.Request.RequestUri.LocalPath) ? "/" : context.Request.RequestUri.LocalPath; info.Port = context.Request.RequestUri.Port; } if (context.Request.Headers.Referrer != null) { info.Referrer = context.Request.Headers.Referrer.ToString(); } var exclusionList = config.DataExclusions as string[] ?? config.DataExclusions.ToArray(); if (config.IncludeCookies) { info.Cookies = context.Request.Headers.GetCookies().ToDictionary(exclusionList); } if (config.IncludeQueryString) { info.QueryString = context.Request.RequestUri.ParseQueryString().ToDictionary(exclusionList); } // TODO Collect form data. return(info); }
public void CanUpdateSettingsFromServer() { var config = new ExceptionlessConfiguration(DependencyResolver.Default) { ApiKey = "LhhP1C9gijpSKCslHHCvwdSIz298twx271n1l6xw", Settings = { ["LocalSetting"] = "1", ["LocalSettingToOverride"] = "1" } }; var submissionClient = new Mock <ISubmissionClient>(); submissionClient.Setup(m => m.PostEvents(It.IsAny <IEnumerable <Event> >(), config, It.IsAny <IJsonSerializer>())) .Callback(() => SettingsManager.CheckVersion(1, config)) .Returns(() => new SubmissionResponse(202, "Accepted")); submissionClient.Setup(m => m.GetSettings(config, 0, It.IsAny <IJsonSerializer>())) .Returns(() => new SettingsResponse(true, new SettingsDictionary { { "Test", "Test" }, { "LocalSettingToOverride", "2" } }, 1)); config.Resolver.Register <ISubmissionClient>(submissionClient.Object); var client = new ExceptionlessClient(config); Assert.Equal(2, client.Configuration.Settings.Count); Assert.False(client.Configuration.Settings.ContainsKey("Test")); Assert.Equal("1", client.Configuration.Settings["LocalSettingToOverride"]); client.SubmitEvent(new Event { Type = "Log", Message = "Test" }); client.ProcessQueue(); Assert.True(client.Configuration.Settings.ContainsKey("Test")); Assert.Equal("2", client.Configuration.Settings["LocalSettingToOverride"]); Assert.Equal(3, client.Configuration.Settings.Count); var storage = config.Resolver.GetFileStorage() as InMemoryObjectStorage; Assert.NotNull(storage); Assert.NotNull(config.GetQueueName()); Assert.True(storage.Exists(Path.Combine(config.GetQueueName(), "server-settings.json"))); config.Settings.Clear(); config.ApplySavedServerSettings(); Assert.True(client.Configuration.Settings.ContainsKey("Test")); Assert.Equal("2", client.Configuration.Settings["LocalSettingToOverride"]); Assert.Equal(2, client.Configuration.Settings.Count); }
public ExceptionlessClient(ExceptionlessConfiguration configuration) { if (configuration == null) throw new ArgumentNullException("configuration"); Configuration = configuration; configuration.Resolver.Register(typeof(ExceptionlessConfiguration), () => Configuration); _log = new Lazy<IExceptionlessLog>(() => Configuration.Resolver.GetLog()); _queue = new Lazy<IEventQueue>(() => { // config can't be changed after the queue starts up. Configuration.LockConfig(); return Configuration.Resolver.GetEventQueue(); }); _submissionClient = new Lazy<ISubmissionClient>(() => Configuration.Resolver.GetSubmissionClient()); _lastReferenceIdManager = new Lazy<ILastReferenceIdManager>(() => Configuration.Resolver.GetLastReferenceIdManager()); }
public static void UpdateSettings(ExceptionlessConfiguration config) { var serializer = config.Resolver.GetJsonSerializer(); var client = config.Resolver.GetSubmissionClient(); var response = client.GetSettings(config, serializer); if (!response.Success) return; config.Settings.Apply(response.Settings); var persistedClientData = config.Resolver.Resolve<PersistedDictionary>(); persistedClientData[String.Concat(config.GetQueueName(), "-ServerConfigVersion")] = response.SettingsVersion.ToString(); var fileStorage = config.Resolver.GetFileStorage(); fileStorage.SaveObject(GetConfigPath(config), response.Settings, serializer); }
public static int GetVersion(ExceptionlessConfiguration config) { if (config == null) return 0; if (String.IsNullOrEmpty(config.ApiKey) || String.Equals(config.ApiKey, "API_KEY_HERE", StringComparison.OrdinalIgnoreCase)) { config.Resolver.GetLog().Error(typeof(SettingsManager), "Unable to get version: ApiKey is not set."); return 0; } try { var persistedClientData = config.Resolver.Resolve<PersistedDictionary>(); return persistedClientData.GetInt32(String.Concat(config.GetQueueName(), "-ServerConfigVersion"), 0); } catch (Exception ex) { config.Resolver.GetLog().Error(typeof(SettingsManager), ex, "Error occurred getting settings version."); return 0; } }
public static void AddDefaultPlugins(ExceptionlessConfiguration config) { config.AddPlugin<HandleAggregateExceptionsPlugin>(); config.AddPlugin<EventExclusionPlugin>(); config.AddPlugin<ConfigurationDefaultsPlugin>(); #if !PORTABLE && !NETSTANDARD1_2 config.AddPlugin<ErrorPlugin>(); #else config.AddPlugin<SimpleErrorPlugin>(); #endif config.AddPlugin<DuplicateCheckerPlugin>(); config.AddPlugin<EnvironmentInfoPlugin>(); #if !PORTABLE && !NETSTANDARD1_2 config.AddPlugin<VersionPlugin>(); #endif config.AddPlugin<SubmissionMethodPlugin>(); config.AddPlugin<CancelSessionsWithNoUserPlugin>(); }
protected virtual HttpWebRequest CreateHttpWebRequest(ExceptionlessConfiguration config, string endPoint) { var request = (HttpWebRequest)WebRequest.Create(String.Concat(config.GetServiceEndPoint(), endPoint)); request.AddAuthorizationHeader(config); request.SetUserAgent(config.UserAgent); request.AllowAutoRedirect = true; request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.None; try { request.UseDefaultCredentials = true; // if (Credentials != null) // request.Credentials = Credentials; } catch (Exception) {} return(request); }
public static void ApplySavedServerSettings(ExceptionlessConfiguration config) { if (config == null) { return; } if (String.IsNullOrEmpty(config.ApiKey) || String.Equals(config.ApiKey, "API_KEY_HERE", StringComparison.OrdinalIgnoreCase)) { config.Resolver.GetLog().Error(typeof(SettingsManager), "Unable to apply saved server settings: ApiKey is not set."); return; } var savedServerSettings = GetSavedServerSettings(config); config.Settings.Apply(savedServerSettings); }
private static SettingsDictionary GetSavedServerSettings(ExceptionlessConfiguration config) { string configPath = GetConfigPath(config); if (String.IsNullOrEmpty(configPath)) return new SettingsDictionary(); var fileStorage = config.Resolver.GetFileStorage(); if (!fileStorage.Exists(configPath)) return new SettingsDictionary(); try { return fileStorage.GetObject<SettingsDictionary>(configPath); } catch (Exception ex) { config.Resolver.GetLog().FormattedError(typeof(SettingsManager), ex, "Unable to read and apply saved server settings: {0}", ex.Message); } return new SettingsDictionary(); }
public static void CheckVersion(int version, ExceptionlessConfiguration config) { if (String.IsNullOrEmpty(config.ApiKey) || String.Equals(config.ApiKey, "API_KEY_HERE", StringComparison.OrdinalIgnoreCase)) { config.Resolver.GetLog().Error(typeof(SettingsManager), "Unable to check version: ApiKey is not set."); return; } var persistedClientData = config.Resolver.Resolve <PersistedDictionary>(); if (version <= persistedClientData.GetInt32(String.Concat(config.GetQueueName(), "-ServerConfigVersion"), -1)) { return; } UpdateSettings(config); }
public void SendHeartbeat(string sessionIdOrUserId, bool closeSession, ExceptionlessConfiguration config) { if (!config.IsValid) { return; } string url = String.Format("{0}/events/session/heartbeat?id={1}&close={2}", GetHeartbeatServiceEndPoint(config), sessionIdOrUserId, closeSession); try { _client.Value.AddAuthorizationHeader(config.ApiKey); _client.Value.GetAsync(url).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (Exception ex) { var log = config.Resolver.GetLog(); log.Error(String.Concat("Error submitting heartbeat: ", ex.GetMessage())); } }
protected virtual HttpClient CreateHttpClient(ExceptionlessConfiguration config) { #if NET45 var handler = new WebRequestHandler { UseDefaultCredentials = true }; #else var handler = new HttpClientHandler { UseDefaultCredentials = true }; #endif var callback = config.ServerCertificateValidationCallback; if (callback != null) { #if NET45 handler.ServerCertificateValidationCallback = (s, c, ch, p) => Validate(s, c, ch, p, callback); #else handler.ServerCertificateCustomValidationCallback = (m, c, ch, p) => Validate(m, c, ch, p, callback); #endif } if (handler.SupportsAutomaticDecompression) { handler.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.None; } if (handler.SupportsRedirectConfiguration) { handler.AllowAutoRedirect = true; } if (handler.SupportsProxy && config.Proxy != null) { handler.Proxy = config.Proxy; } var client = new HttpClient(handler, true); client.DefaultRequestHeaders.ConnectionClose = true; client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.ExpectContinue = false; client.DefaultRequestHeaders.UserAgent.ParseAdd(config.UserAgent); return(client); }
public static void ApplySavedServerSettings(ExceptionlessConfiguration config) { string configPath = GetConfigPath(config); var fileStorage = config.Resolver.GetFileStorage(); if (!fileStorage.Exists(configPath)) { return; } try { var serializer = config.Resolver.GetJsonSerializer(); var savedServerSettings = fileStorage.GetObject <SettingsDictionary>(configPath, serializer); config.Settings.Apply(savedServerSettings); } catch (Exception ex) { config.Resolver.GetLog().FormattedError(typeof(SettingsManager), ex, "Unable to read and apply saved server settings: {0}", ex.Message); } }
public static void AddDefaultPlugins(ExceptionlessConfiguration config) { config.AddPlugin <HandleAggregateExceptionsPlugin>(); config.AddPlugin <EventExclusionPlugin>(); config.AddPlugin <ConfigurationDefaultsPlugin>(); #if !PORTABLE && !NETSTANDARD1_2 config.AddPlugin <ErrorPlugin>(); #else config.AddPlugin <SimpleErrorPlugin>(); #endif config.AddPlugin <DuplicateCheckerPlugin>(); config.AddPlugin <EnvironmentInfoPlugin>(); #if !PORTABLE && !NETSTANDARD1_2 config.AddPlugin <VersionPlugin>(); #endif config.AddPlugin <SubmissionMethodPlugin>(); config.AddPlugin <CancelSessionsWithNoUserPlugin>(); }
public void SubmitAsync() { using (WebApp.Start(Settings.Current.BaseURL, AppBuilder.Build)) { var events = new List <Event> { new Event { Message = "Testing" } }; var configuration = ExceptionlessConfiguration.CreateDefault(); var serializer = new DefaultJsonSerializer(); var client = new DefaultSubmissionClient(); var response = client.Submit(events, configuration, serializer); Assert.True(response.Success, response.Message); Assert.NotEqual(-1, response.SettingsVersion); Assert.Null(response.Message); } }
public SubmissionResponse Submit(IEnumerable <Event> events, ExceptionlessConfiguration configuration, IJsonSerializer serializer) { HttpWebRequest client = WebRequest.CreateHttp(String.Concat(configuration.GetServiceEndPoint(), "events")); client.SetUserAgent(configuration.UserAgent); client.AddAuthorizationHeader(configuration); var data = serializer.Serialize(events); var response = client.PostJsonAsync(data).Result; int settingsVersion; if (!Int32.TryParse(response.Headers[ExceptionlessHeaders.ConfigurationVersion], out settingsVersion)) { settingsVersion = -1; } return(new SubmissionResponse((int)response.StatusCode, settingsVersion, response.StatusCode == HttpStatusCode.Accepted ? null : response.GetResponseText())); }
public static void UpdateSettings(ExceptionlessConfiguration config, int?version = null) { if (config == null || !config.IsValid || !config.Enabled || _isUpdatingSettings) { return; } try { _isUpdatingSettings = true; if (!version.HasValue || version < 0) { version = GetVersion(config); } var serializer = config.Resolver.GetJsonSerializer(); var client = config.Resolver.GetSubmissionClient(); var response = client.GetSettings(config, version.Value, serializer); if (!response.Success || response.Settings == null) { return; } var savedServerSettings = GetSavedServerSettings(config); config.Settings.Apply(response.Settings); // TODO: Store snapshot of settings after reading from config and attributes and use that to revert to defaults. // Remove any existing server settings that are not in the new server settings. foreach (string key in savedServerSettings.Keys.Except(response.Settings.Keys)) { config.Settings.Remove(key); } var persistedClientData = config.Resolver.Resolve <PersistedDictionary>(); persistedClientData[String.Concat(config.GetQueueName(), "-ServerConfigVersion")] = response.SettingsVersion.ToString(); var fileStorage = config.Resolver.GetFileStorage(); fileStorage.SaveObject(GetConfigPath(config), response.Settings); } catch (Exception ex) { config.Resolver.GetLog().Error(typeof(SettingsManager), ex, "Error occurred updating settings."); } finally { _isUpdatingSettings = false; } }
public SubmissionResponse PostEvents(IEnumerable <Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) { var data = events.ToList(); data.ForEach(e => { if (e.Date == DateTimeOffset.MinValue) { e.Date = DateTimeOffset.Now; } if (String.IsNullOrEmpty(e.Type)) { e.Type = Event.KnownTypes.Log; } }); Events.AddRange(data); return(new SubmissionResponse(202, "Accepted")); }
public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) { var data = serializer.Serialize(description); HttpWebResponse response; try { var request = CreateHttpWebRequest(config, String.Format("events/by-ref/{0}/user-description", referenceId)); response = request.PostJsonAsyncWithCompression(data).Result as HttpWebResponse; } catch (AggregateException aex) { var ex = aex.GetInnermostException() as WebException; if (ex != null) response = (HttpWebResponse)ex.Response; else return new SubmissionResponse(500, message: aex.GetMessage()); } catch (Exception ex) { return new SubmissionResponse(500, message: ex.Message); } return new SubmissionResponse((int)response.StatusCode, response.IsSuccessful() ? null : response.GetResponseText()); }
public SettingsResponse GetSettings(ExceptionlessConfiguration config, IJsonSerializer serializer) { HttpWebResponse response; try { var request = CreateHttpWebRequest(config, "projects/config"); response = request.GetJsonAsync().Result as HttpWebResponse; } catch (Exception ex) { var message = String.Concat("Unable to retrieve configuration settings. Exception: ", ex.GetMessage()); return new SettingsResponse(false, message: message); } if (response == null || response.StatusCode != HttpStatusCode.OK) return new SettingsResponse(false, message: String.Format("Unable to retrieve configuration settings: {0}", GetResponseMessage(response))); var json = response.GetResponseText(); if (String.IsNullOrWhiteSpace(json)) return new SettingsResponse(false, message: "Invalid configuration settings."); var settings = serializer.Deserialize<ClientConfiguration>(json); return new SettingsResponse(true, settings.Settings, settings.Version); }
public SubmissionResponse PostEvents(IEnumerable <Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) { if (!config.IsValid) { return(SubmissionResponse.InvalidClientConfig500); } string data = serializer.Serialize(events); string url = $"{GetServiceEndPoint(config)}/events"; HttpResponseMessage response; try { HttpContent content = new StringContent(data, Encoding.UTF8, "application/json"); // don't compress data smaller than 4kb if (data.Length > 1024 * 4) { content = new GzipContent(content); } _client.Value.AddAuthorizationHeader(config.ApiKey); response = _client.Value.PostAsync(url, content).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (Exception ex) { return(new SubmissionResponse(500, exception: ex)); } if (Int32.TryParse(GetSettingsVersionHeader(response.Headers), out int settingsVersion)) { SettingsManager.CheckVersion(settingsVersion, config); } var message = GetResponseMessage(response); if ((int)response.StatusCode == 200 && "OK".Equals(message, StringComparison.OrdinalIgnoreCase)) { return(SubmissionResponse.Ok200); } return(new SubmissionResponse((int)response.StatusCode, message)); }
public static int GetVersion(ExceptionlessConfiguration config) { if (config == null) { return(0); } if (String.IsNullOrEmpty(config.ApiKey) || String.Equals(config.ApiKey, "API_KEY_HERE", StringComparison.OrdinalIgnoreCase)) { config.Resolver.GetLog().Error(typeof(SettingsManager), "Unable to get version: ApiKey is not set."); return(0); } try { var persistedClientData = config.Resolver.Resolve <PersistedDictionary>(); return(persistedClientData.GetInt32(String.Concat(config.GetQueueName(), "-ServerConfigVersion"), 0)); } catch (Exception ex) { config.Resolver.GetLog().Error(typeof(SettingsManager), ex, "Error occurred getting settings version."); return(0); } }
public SettingsResponse GetSettings(ExceptionlessConfiguration config, int version, IJsonSerializer serializer) { if (!config.IsValid) { return(new SettingsResponse(false, message: "Invalid client configuration settings.")); } string url = String.Format("{0}/projects/config?v={1}", GetConfigServiceEndPoint(config), version); HttpResponseMessage response; try { _client.Value.AddAuthorizationHeader(config.ApiKey); response = _client.Value.GetAsync(url).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (Exception ex) { var message = String.Concat("Unable to retrieve configuration settings. Exception: ", ex.GetMessage()); return(new SettingsResponse(false, message: message)); } if (response != null && response.StatusCode == HttpStatusCode.NotModified) { return(new SettingsResponse(false, message: "Settings have not been modified.")); } if (response == null || response.StatusCode != HttpStatusCode.OK) { return(new SettingsResponse(false, message: String.Concat("Unable to retrieve configuration settings: ", GetResponseMessage(response)))); } var json = GetResponseText(response); if (String.IsNullOrWhiteSpace(json)) { return(new SettingsResponse(false, message: "Invalid configuration settings.")); } var settings = serializer.Deserialize <ClientConfiguration>(json); return(new SettingsResponse(true, settings.Settings, settings.Version)); }
public static void UpdateSettings(ExceptionlessConfiguration config) { if (String.IsNullOrEmpty(config.ApiKey) || String.Equals(config.ApiKey, "API_KEY_HERE", StringComparison.OrdinalIgnoreCase)) { config.Resolver.GetLog().Error(typeof(SettingsManager), "Unable to update settings: ApiKey is not set."); return; } var serializer = config.Resolver.GetJsonSerializer(); var client = config.Resolver.GetSubmissionClient(); var response = client.GetSettings(config, serializer); if (!response.Success || response.Settings == null) { return; } var savedServerSettings = GetSavedServerSettings(config); config.Settings.Apply(response.Settings); // TODO: Store snapshot of settings after reading from config and attributes and use that to revert to defaults. // Remove any existing server settings that are not in the new server settings. foreach (string key in savedServerSettings.Keys.Except(response.Settings.Keys)) { if (config.Settings.ContainsKey(key)) { config.Settings.Remove(key); } } var persistedClientData = config.Resolver.Resolve <PersistedDictionary>(); persistedClientData[String.Concat(config.GetQueueName(), "-ServerConfigVersion")] = response.SettingsVersion.ToString(); var fileStorage = config.Resolver.GetFileStorage(); fileStorage.SaveObject(GetConfigPath(config), response.Settings); }
public static void UpdateSettings(ExceptionlessConfiguration config) { var serializer = config.Resolver.GetJsonSerializer(); var client = config.Resolver.GetSubmissionClient(); var response = client.GetSettings(config, serializer); if (!response.Success) { return; } config.Settings.Apply(response.Settings); var persistedClientData = config.Resolver.Resolve <PersistedDictionary>(); persistedClientData[String.Concat(config.GetQueueName(), "-ServerConfigVersion")] = response.SettingsVersion.ToString(); var fileStorage = config.Resolver.GetFileStorage(); fileStorage.SaveObject(GetConfigPath(config), response.Settings, serializer); }
protected virtual HttpClient CreateHttpClient(ExceptionlessConfiguration config) { #if NET45 var handler = new WebRequestHandler { UseDefaultCredentials = true }; handler.ServerCertificateValidationCallback = delegate { return(true); }; #else var handler = new HttpClientHandler { UseDefaultCredentials = true }; #if !PORTABLE && !NETSTANDARD1_2 //handler.ServerCertificateCustomValidationCallback = delegate { return true; }; #endif #endif if (handler.SupportsAutomaticDecompression) { handler.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.None; } if (handler.SupportsRedirectConfiguration) { handler.AllowAutoRedirect = true; } if (handler.SupportsProxy && config.Proxy != null) { handler.Proxy = config.Proxy; } var client = new HttpClient(handler, true); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.ExpectContinue = false; client.DefaultRequestHeaders.UserAgent.ParseAdd(config.UserAgent); return(client); }
public SettingsResponse GetSettings(ExceptionlessConfiguration configuration, IJsonSerializer serializer) { HttpWebRequest client = WebRequest.CreateHttp(String.Concat(configuration.GetServiceEndPoint(), "projects/config")); client.AddAuthorizationHeader(configuration); var response = client.GetJsonAsync().Result; if (response == null || response.StatusCode != HttpStatusCode.OK) { return(new SettingsResponse(false, message: "Unable to retrieve configuration settings.")); } var json = response.GetResponseText(); if (String.IsNullOrWhiteSpace(json)) { return(new SettingsResponse(false, message: "Invalid configuration settings.")); } var settings = serializer.Deserialize <ClientConfiguration>(json); return(new SettingsResponse(true, settings.Settings, settings.Version)); }
private static SettingsDictionary GetSavedServerSettings(ExceptionlessConfiguration config) { string configPath = GetConfigPath(config); if (String.IsNullOrEmpty(configPath)) { return(new SettingsDictionary()); } var fileStorage = config.Resolver.GetFileStorage(); if (!fileStorage.Exists(configPath)) { return(new SettingsDictionary()); } try { return(fileStorage.GetObject <SettingsDictionary>(configPath)); } catch (Exception ex) { config.Resolver.GetLog().FormattedError(typeof(SettingsManager), ex, "Unable to read and apply saved server settings: {0}", ex.Message); } return(new SettingsDictionary()); }
public SubmissionResponse PostEvents(IEnumerable <Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) { if (!config.IsValid) { return(new SubmissionResponse(500, message: "Invalid client configuration settings")); } string data = serializer.Serialize(events); string url = String.Format("{0}/events", GetServiceEndPoint(config)); HttpResponseMessage response; try { HttpContent content = new StringContent(data, Encoding.UTF8, "application/json"); // don't compress data smaller than 4kb if (data.Length > 1024 * 4) { content = new GzipContent(content); } _client.Value.AddAuthorizationHeader(config.ApiKey); response = _client.Value.PostAsync(url, content).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (Exception ex) { return(new SubmissionResponse(500, message: ex.Message)); } int settingsVersion; if (Int32.TryParse(GetSettingsVersionHeader(response.Headers), out settingsVersion)) { SettingsManager.CheckVersion(settingsVersion, config); } return(new SubmissionResponse((int)response.StatusCode, GetResponseMessage(response))); }