Ejemplo n.º 1
0
        private string GetVersionFromLoadedAssemblies(IExceptionlessLog log)
        {
            try {
                foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies().Where(a => !a.IsDynamic && a != typeof(ExceptionlessClient).GetTypeInfo().Assembly&& a != GetType().GetTypeInfo().Assembly&& a != typeof(object).GetTypeInfo().Assembly))
                {
                    if (String.IsNullOrEmpty(assembly.FullName) || assembly.FullName.StartsWith("System.") || assembly.FullName.StartsWith("Microsoft."))
                    {
                        continue;
                    }

                    string company = assembly.GetCompany();
                    if (!String.IsNullOrEmpty(company) && (String.Equals(company, "Exceptionless", StringComparison.OrdinalIgnoreCase) || String.Equals(company, "Microsoft Corporation", StringComparison.OrdinalIgnoreCase)))
                    {
                        continue;
                    }

#if !NETSTANDARD1_3 && !NETSTANDARD1_4
                    if (!assembly.GetReferencedAssemblies().Any(an => String.Equals(an.FullName, typeof(ExceptionlessClient).GetTypeInfo().Assembly.FullName)))
                    {
                        continue;
                    }
#endif

                    string version = GetVersionFromAssembly(assembly);
                    if (!String.IsNullOrEmpty(version))
                    {
                        return(version);
                    }
                }
            } catch (Exception ex) {
                log.FormattedError(typeof(VersionPlugin), ex, "Unable to get version from loaded assemblies. Error: {0}", ex.Message);
            }

            return(null);
        }
Ejemplo n.º 2
0
        private string GetVersionFromRuntimeInfo(IExceptionlessLog log)
        {
#if NETSTANDARD1_3 || NETSTANDARD1_4 || NETSTANDARD1_5 || NETSTANDARD2_0
            try {
                var platformService = Microsoft.Extensions.PlatformAbstractions.PlatformServices.Default;
                return(platformService.Application.ApplicationVersion);
            } catch (Exception ex) {
                log.FormattedError(typeof(VersionPlugin), ex, "Unable to get Platform Services instance. Error: {0}", ex.Message);
            }
#endif
            return(null);
        }
        private string GetVersion(IExceptionlessLog log)
        {
            if (_appVersionLoaded)
            {
                return(_appVersion);
            }

            var entryAssembly = GetEntryAssembly(log);

            try {
                string version = GetVersionFromAssembly(entryAssembly);
                if (!String.IsNullOrEmpty(version))
                {
                    _appVersion       = version;
                    _appVersionLoaded = true;

                    return(_appVersion);
                }
            } catch (Exception ex) {
                log.FormattedError(typeof(VersionPlugin), ex, "Unable to get version from loaded assemblies. Error: {0}", ex.Message);
            }

#if NETSTANDARD2_0
            try {
                var platformService = Microsoft.Extensions.PlatformAbstractions.PlatformServices.Default;

                _appVersion       = platformService.Application.ApplicationVersion;
                _appVersionLoaded = true;

                return(_appVersion);
            } catch (Exception ex) {
                log.FormattedError(typeof(VersionPlugin), ex, "Unable to get Platform Services instance. Error: {0}", ex.Message);
            }
#endif

            _appVersion       = null;
            _appVersionLoaded = true;

            return(null);
        }
        private Assembly GetEntryAssembly(IExceptionlessLog log)
        {
            var entryAssembly = Assembly.GetEntryAssembly();

            if (IsUserAssembly(entryAssembly))
            {
                return(entryAssembly);
            }

            try {
                var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a =>
                                                                               !a.IsDynamic &&
                                                                               a != typeof(ExceptionlessClient).GetTypeInfo().Assembly &&
                                                                               a != GetType().GetTypeInfo().Assembly &&
                                                                               a != typeof(object).GetTypeInfo().Assembly);

                return(assemblies.FirstOrDefault(a => IsUserAssembly(a)));
            } catch (Exception ex) {
                log.FormattedError(typeof(VersionPlugin), ex, "Unable to get entry assembly. Error: {0}", ex.Message);
            }

            return(null);
        }
Ejemplo n.º 5
0
        public void Process()
        {
            if (_processingQueue)
            {
                return;
            }

            if (!_config.Enabled)
            {
                _log.Info(typeof(DefaultEventQueue), "Configuration is disabled. The queue will not be processed.");
                return;
            }

            _log.Trace(typeof(DefaultEventQueue), "Processing queue...");
            _processingQueue = true;

            try {
                _storage.CleanupQueueFiles(_config.GetQueueName(), _config.QueueMaxAge, _config.QueueMaxAttempts);
                _storage.ReleaseStaleLocks(_config.GetQueueName());

                DateTime maxCreatedDate = DateTime.Now;
                int      batchSize      = _config.SubmissionBatchSize;
                var      batch          = _storage.GetEventBatch(_config.GetQueueName(), _serializer, batchSize, maxCreatedDate);
                while (batch.Any())
                {
                    bool deleteBatch = true;

                    try {
                        var events   = batch.Select(b => b.Item2).ToList();
                        var response = _client.PostEvents(events, _config, _serializer);
                        if (response.Success)
                        {
                            _log.FormattedInfo(typeof(DefaultEventQueue), "Sent {0} events to \"{1}\".", batch.Count, _config.ServerUrl);
                        }
                        else if (response.ServiceUnavailable)
                        {
                            // You are currently over your rate limit or the servers are under stress.
                            _log.Error(typeof(DefaultEventQueue), "Server returned service unavailable.");
                            SuspendProcessing();
                            deleteBatch = false;
                        }
                        else if (response.PaymentRequired)
                        {
                            // If the organization over the rate limit then discard the event.
                            _log.Info(typeof(DefaultEventQueue), "Too many events have been submitted, please upgrade your plan.");
                            SuspendProcessing(discardFutureQueuedItems: true, clearQueue: true);
                        }
                        else if (response.UnableToAuthenticate)
                        {
                            // The api key was suspended or could not be authorized.
                            _log.Info(typeof(DefaultEventQueue), "Unable to authenticate, please check your configuration. The event will not be submitted.");
                            SuspendProcessing(TimeSpan.FromMinutes(15));
                        }
                        else if (response.NotFound || response.BadRequest)
                        {
                            // The service end point could not be found.
                            _log.FormattedError(typeof(DefaultEventQueue), "Error while trying to submit data: {0}", response.Message);
                            SuspendProcessing(TimeSpan.FromHours(4));
                        }
                        else if (response.RequestEntityTooLarge)
                        {
                            if (batchSize > 1)
                            {
                                _log.Error(typeof(DefaultEventQueue), "Event submission discarded for being too large. The event will be retried with a smaller batch size.");
                                batchSize   = Math.Max(1, (int)Math.Round(batchSize / 1.5d, 0));
                                deleteBatch = false;
                            }
                            else
                            {
                                _log.Error(typeof(DefaultEventQueue), "Event submission discarded for being too large. The event will not be submitted.");
                            }
                        }
                        else if (!response.Success)
                        {
                            _log.Error(typeof(DefaultEventQueue), String.Concat("An error occurred while submitting events: ", response.Message));
                            SuspendProcessing();
                            deleteBatch = false;
                        }

                        OnEventsPosted(new EventsPostedEventArgs {
                            Events = events, Response = response
                        });
                    } catch (AggregateException ex) {
                        _log.Error(typeof(DefaultEventQueue), ex, String.Concat("An error occurred while submitting events: ", ex.Flatten().Message));
                        SuspendProcessing();
                        deleteBatch = false;
                    } catch (Exception ex) {
                        _log.Error(typeof(DefaultEventQueue), ex, String.Concat("An error occurred while submitting events: ", ex.Message));
                        SuspendProcessing();
                        deleteBatch = false;
                    }

                    if (deleteBatch)
                    {
                        _storage.DeleteBatch(batch);
                    }
                    else
                    {
                        _storage.ReleaseBatch(batch);
                    }

                    if (!deleteBatch || IsQueueProcessingSuspended)
                    {
                        break;
                    }

                    batch = _storage.GetEventBatch(_config.GetQueueName(), _serializer, batchSize, maxCreatedDate);
                }
            } catch (Exception ex) {
                _log.Error(typeof(DefaultEventQueue), ex, String.Concat("An error occurred while processing the queue: ", ex.Message));
                SuspendProcessing();
            } finally {
                _processingQueue = false;
            }
        }
Ejemplo n.º 6
0
        public void Process()
        {
            if (_processingQueue)
            {
                return;
            }

            _log.Info(typeof(DefaultEventQueue), "Processing queue...");
            if (!_config.Enabled)
            {
                _log.Info(typeof(DefaultEventQueue), "Configuration is disabled. The queue will not be processed.");
                return;
            }

            _processingQueue = true;

            try {
                _storage.CleanupQueueFiles(_config.GetQueueName());
                _storage.ReleaseStaleLocks(_config.GetQueueName());

                var batch = _storage.GetEventBatch(_config.GetQueueName(), _serializer);
                while (batch.Any())
                {
                    bool deleteBatch = true;

                    try {
                        var response = _client.PostEvents(batch.Select(b => b.Item2), _config, _serializer);
                        if (response.ServiceUnavailable)
                        {
                            // You are currently over your rate limit or the servers are under stress.
                            _log.Error(typeof(DefaultEventQueue), "Server returned service unavailable.");
                            SuspendProcessing();
                            deleteBatch = false;
                        }
                        else if (response.PaymentRequired)
                        {
                            // If the organization over the rate limit then discard the event.
                            _log.Info(typeof(DefaultEventQueue), "Too many events have been submitted, please upgrade your plan.");
                            SuspendProcessing(discardFutureQueuedItems: true, clearQueue: true);
                        }
                        else if (response.UnableToAuthenticate)
                        {
                            // The api key was suspended or could not be authorized.
                            _log.Info(typeof(DefaultEventQueue), "Unable to authenticate, please check your configuration. The event will not be submitted.");
                            SuspendProcessing(TimeSpan.FromMinutes(15));
                        }
                        else if (response.NotFound || response.BadRequest)
                        {
                            // The service end point could not be found.
                            _log.FormattedError(typeof(DefaultEventQueue), "Error while trying to submit data: {0}", response.Message);
                            SuspendProcessing(TimeSpan.FromHours(4));
                        }
                        else if (!response.Success)
                        {
                            _log.Error(typeof(DefaultEventQueue), String.Format("An error occurred while submitting events: {0}", response.Message));
                            SuspendProcessing();
                            deleteBatch = false;
                        }
                    } catch (Exception ex) {
                        _log.Error(typeof(DefaultEventQueue), ex, String.Concat("An error occurred while submitting events: ", ex.Message));
                        SuspendProcessing();
                        deleteBatch = false;
                    }

                    if (deleteBatch)
                    {
                        _storage.DeleteBatch(batch);
                    }
                    else
                    {
                        _storage.ReleaseBatch(batch);
                    }

                    if (!deleteBatch || IsQueueProcessingSuspended)
                    {
                        break;
                    }

                    batch = _storage.GetEventBatch(_config.GetQueueName(), _serializer);
                }
            } catch (Exception ex) {
                _log.Error(typeof(DefaultEventQueue), ex, String.Concat("An error occurred while processing the queue: ", ex.Message));
                SuspendProcessing();
            } finally {
                _processingQueue = false;
            }
        }