public async Task ApplicationStatusesTest()
        {
            var          utcnow          = DateTime.UtcNow.Date;
            var          elasticLogStore = new ElasticSearchLogStore(() => utcnow);
            const string appPath         = "c:\\###rather_not_existing_application_path###";

            var startDate = DateTime.UtcNow.AddMinutes(-1);

            var expectedAppStatus = new LastApplicationStatus {
                ApplicationPath   = appPath,
                Server            = "SRV1",
                LastUpdateTimeUtc = DateTime.UtcNow
            };
            await elasticLogStore.UpdateApplicationStatusesAsync(new[] { expectedAppStatus });

            await Task.Delay(2000);

            var actualAppStatus = (await elasticLogStore.GetApplicationStatusesAsync(startDate)).FirstOrDefault(
                st => string.Equals(st.ApplicationPath, expectedAppStatus.ApplicationPath, StringComparison.Ordinal));

            Assert.NotNull(actualAppStatus);
            Assert.Equal(expectedAppStatus.ApplicationPath, actualAppStatus.ApplicationPath);
            Assert.Equal(expectedAppStatus.Cpu, 0);
            Assert.Equal(expectedAppStatus.Memory, 0);
            Assert.Null(actualAppStatus.LastErrorTimeUtc);
            Assert.Null(actualAppStatus.LastPerformanceDataUpdateTimeUtc);

            expectedAppStatus.LastErrorType    = "TestException";
            expectedAppStatus.LastErrorTimeUtc = DateTime.UtcNow;
            await elasticLogStore.UpdateApplicationStatusesAsync(new[] { expectedAppStatus });

            await Task.Delay(2000);

            actualAppStatus = (await elasticLogStore.GetApplicationStatusesAsync(startDate)).FirstOrDefault(
                st => string.Equals(st.ApplicationPath, expectedAppStatus.ApplicationPath, StringComparison.Ordinal));
            Assert.NotNull(actualAppStatus);
            Assert.Equal(expectedAppStatus.ApplicationPath, actualAppStatus.ApplicationPath);
            Assert.Equal(expectedAppStatus.Cpu, 0);
            Assert.Equal(expectedAppStatus.Memory, 0);
            Assert.Equal(expectedAppStatus.LastErrorType, actualAppStatus.LastErrorType);
            Assert.NotNull(actualAppStatus.LastErrorTimeUtc);
            Assert.Null(actualAppStatus.LastPerformanceDataUpdateTimeUtc);

            expectedAppStatus.Cpu    = 10f;
            expectedAppStatus.Memory = 1000f;
            expectedAppStatus.LastPerformanceDataUpdateTimeUtc = DateTime.UtcNow;
            await elasticLogStore.UpdateApplicationStatusesAsync(new[] { expectedAppStatus });

            await Task.Delay(2000);

            actualAppStatus = (await elasticLogStore.GetApplicationStatusesAsync(startDate)).FirstOrDefault(
                st => string.Equals(st.ApplicationPath, expectedAppStatus.ApplicationPath, StringComparison.Ordinal));
            Assert.NotNull(actualAppStatus);
            Assert.Equal(expectedAppStatus.ApplicationPath, actualAppStatus.ApplicationPath);
            Assert.Equal(expectedAppStatus.LastErrorType, actualAppStatus.LastErrorType);
            Assert.NotNull(actualAppStatus.LastErrorTimeUtc);
            Assert.Equal(expectedAppStatus.Cpu, 10f);
            Assert.Equal(expectedAppStatus.Memory, 1000f);
            Assert.NotNull(actualAppStatus.LastPerformanceDataUpdateTimeUtc);
        }
Exemple #2
0
        private LastApplicationStatus CreateApplicationStatus(LogRecord logrec)
        {
            var appStatus = new LastApplicationStatus {
                ApplicationPath   = logrec.ApplicationPath,
                Server            = logrec.Server,
                LastUpdateTimeUtc = DateTime.UtcNow
            };

            if (logrec.LogLevel >= LogRecord.ELogLevel.Error)
            {
                appStatus.LastErrorTimeUtc = logrec.TimeUtc;
                appStatus.LastErrorType    = logrec.ExceptionType;
            }

            if (logrec.PerformanceData != null && logrec.PerformanceData.Count > 0)
            {
                appStatus.LastPerformanceDataUpdateTimeUtc = DateTime.UtcNow;
                float v;
                if (logrec.PerformanceData.TryGetValue("CPU", out v))
                {
                    appStatus.Cpu = v;
                }
                if (logrec.PerformanceData.TryGetValue("Memory", out v))
                {
                    appStatus.Memory = v;
                }
            }

            return(appStatus);
        }
        public virtual async Task UpdateApplicationStatusAsync(LastApplicationStatus appStatus)
        {
            var apphash = GetApplicationHash(appStatus.ApplicationPath);

            using (var conn = CreateConnection()) {
                conn.Open();
                await logTable.UpdateApplicationStatus(conn, null, apphash, appStatus);
            }
        }
        public async Task UpdateApplicationStatusAsync(LastApplicationStatus appStatus)
        {
            var apphash = GetApplicationHash(appStatus.ApplicationPath);

            using (var conn = new MySqlConnection(MySqlLogStoreConfiguration.ConnectionString)) {
                await conn.OpenAsync();

                await logTable.UpdateApplicationStatus(conn, null, apphash, appStatus);
            }
        }
        public async Task ApplicationStatusTest()
        {
            var          utcnow        = DateTime.UtcNow.Date;
            var          mysqlLogStore = new MySqlLogStore(() => utcnow);
            const string appPath       = "###rather_not_existing_application_path###";
            var          hash          = BitConverter.ToString(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(appPath))).Replace("-", String.Empty);
            var          startDate     = DateTime.UtcNow.AddMinutes(-1);

            var expectedAppStatus = new LastApplicationStatus {
                ApplicationPath   = appPath,
                Server            = "SRV1",
                LastUpdateTimeUtc = DateTime.UtcNow
            };
            await mysqlLogStore.UpdateApplicationStatusAsync(expectedAppStatus);

            var actualAppStatus = (await mysqlLogStore.GetApplicationStatusesAsync(startDate)).FirstOrDefault(
                st => string.Equals(st.ApplicationPath, expectedAppStatus.ApplicationPath, StringComparison.Ordinal));

            Assert.NotNull(actualAppStatus);
            Assert.Equal(expectedAppStatus.ApplicationPath, actualAppStatus.ApplicationPath);
            Assert.Equal(expectedAppStatus.Cpu, 0);
            Assert.Equal(expectedAppStatus.Memory, 0);
            Assert.Null(actualAppStatus.LastErrorTimeUtc);
            Assert.Null(actualAppStatus.LastPerformanceDataUpdateTimeUtc);

            expectedAppStatus.LastErrorType    = "TestException";
            expectedAppStatus.LastErrorTimeUtc = DateTime.UtcNow;
            await mysqlLogStore.UpdateApplicationStatusAsync(expectedAppStatus);

            actualAppStatus = (await mysqlLogStore.GetApplicationStatusesAsync(startDate)).FirstOrDefault(
                st => string.Equals(st.ApplicationPath, expectedAppStatus.ApplicationPath, StringComparison.Ordinal));
            Assert.NotNull(actualAppStatus);
            Assert.Equal(expectedAppStatus.ApplicationPath, actualAppStatus.ApplicationPath);
            Assert.Equal(expectedAppStatus.Cpu, 0);
            Assert.Equal(expectedAppStatus.Memory, 0);
            Assert.Equal(expectedAppStatus.LastErrorType, actualAppStatus.LastErrorType);
            Assert.NotNull(actualAppStatus.LastErrorTimeUtc);
            Assert.Null(actualAppStatus.LastPerformanceDataUpdateTimeUtc);

            expectedAppStatus.Cpu    = 10f;
            expectedAppStatus.Memory = 1000f;
            expectedAppStatus.LastPerformanceDataUpdateTimeUtc = DateTime.UtcNow;
            await mysqlLogStore.UpdateApplicationStatusAsync(expectedAppStatus);

            actualAppStatus = (await mysqlLogStore.GetApplicationStatusesAsync(startDate)).FirstOrDefault(
                st => string.Equals(st.ApplicationPath, expectedAppStatus.ApplicationPath, StringComparison.Ordinal));
            Assert.NotNull(actualAppStatus);
            Assert.Equal(expectedAppStatus.ApplicationPath, actualAppStatus.ApplicationPath);
            Assert.Equal(expectedAppStatus.LastErrorType, actualAppStatus.LastErrorType);
            Assert.NotNull(actualAppStatus.LastErrorTimeUtc);
            Assert.Equal(expectedAppStatus.Cpu, 10f);
            Assert.Equal(expectedAppStatus.Memory, 1000f);
            Assert.NotNull(actualAppStatus.LastPerformanceDataUpdateTimeUtc);
        }
        public async Task UpdateApplicationStatusAsync(LastApplicationStatus status)
        {
            if (status == null)
            {
                throw new ArgumentException("status == null");
            }

            var getRequest = await eclient.GetAsync(new DocumentPath <ElasticApplicationStatus>(
                                                        GenerateElasticApplicationStatusId(status)).Index(AppStatsIndexName));

            var elasticApplicationStatus = UpdateOrCreateElasticApplicationStatus(
                getRequest.Found ? getRequest.Source : null, status);
            await eclient.IndexAsync(elasticApplicationStatus, ind => ind.Index(AppStatsIndexName));
        }
        private ElasticApplicationStatus UpdateOrCreateElasticApplicationStatus(ElasticApplicationStatus status, LastApplicationStatus appStatus)
        {
            if (status == null)
            {
                status = new ElasticApplicationStatus {
                    Id = GenerateElasticApplicationStatusId(appStatus),
                    ApplicationPath = appStatus.ApplicationPath,
                    Server          = appStatus.Server
                };
            }
            status.LastUpdateTimeUtc = appStatus.LastUpdateTimeUtc;

            if (appStatus.ContainsErrorInformation())
            {
                status.LastErrorTimeUtc = appStatus.LastErrorTimeUtc;
                status.LastErrorType    = appStatus.LastErrorType;
            }

            if (appStatus.ContainsPerformanceData())
            {
                status.Cpu    = appStatus.Cpu;
                status.Memory = appStatus.Memory;
                status.LastPerformanceDataUpdateTimeUtc = appStatus.LastPerformanceDataUpdateTimeUtc;
            }
            return(status);
        }
 private string GenerateElasticApplicationStatusId(LastApplicationStatus appStatus)
 {
     return(BitConverter.ToString(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(
                                                               appStatus.ApplicationPath + appStatus.Server))).Replace("-", string.Empty));
 }
Exemple #9
0
        public async Task UpdateApplicationStatus(IDbConnection conn, IDbTransaction tran, string apphash, LastApplicationStatus status)
        {
            var columnsToUpdate = new List <string>()
            {
                "ApplicationHash", "ApplicationPath", "Server", "LastUpdateTimeUtc"
            };

            if (status.ContainsPerformanceData())
            {
                columnsToUpdate.AddRange(new[] { "Cpu", "Memory", "LastPerformanceDataUpdateTimeUtc" });
            }
            if (status.ContainsErrorInformation())
            {
                columnsToUpdate.AddRange(new[] { "LastErrorTimeUtc", "LastErrorType" });
            }
            var model = new {
                ApplicationHash = apphash,
                status.ApplicationPath,
                status.Server,
                status.Cpu,
                status.Memory,
                status.LastUpdateTimeUtc,
                status.LastPerformanceDataUpdateTimeUtc,
                status.LastErrorType,
                status.LastErrorTimeUtc
            };
            await conn.ExecuteAsync(string.Format("replace into ApplicationStatus ({0}) values (@{1})", string.Join(",", columnsToUpdate),
                                                  string.Join(",@", columnsToUpdate)), model, tran);
        }
Exemple #10
0
        public async Task UpdateApplicationStatus(IDbConnection conn, IDbTransaction tran, string apphash, LastApplicationStatus status)
        {
            var columnsToUpdate = new List <string>()
            {
                "LastUpdateTimeUtc", "ApplicationPath"
            };

            if (status.ContainsPerformanceData())
            {
                columnsToUpdate.AddRange(new[] { "Cpu", "Memory", "LastPerformanceDataUpdateTimeUtc" });
            }
            if (status.ContainsErrorInformation())
            {
                columnsToUpdate.AddRange(new[] { "LastErrorTimeUtc", "LastErrorType" });
            }
            var model = new {
                ApplicationHash = apphash,
                status.ApplicationPath,
                status.Server,
                status.Cpu,
                status.Memory,
                status.LastUpdateTimeUtc,
                status.LastPerformanceDataUpdateTimeUtc,
                status.LastErrorType,
                status.LastErrorTimeUtc
            };

            var buffer = new StringBuilder();

            foreach (var col in columnsToUpdate)
            {
                buffer.AppendFormat("{0}=@{0},", col);
            }
            buffer.Remove(buffer.Length - 1, 1); // last comma

            if (await conn.ExecuteAsync(string.Format("update ApplicationStatus set {0}", buffer.ToString()), model, transaction: tran) == 0)
            {
                columnsToUpdate.Add("ApplicationHash");
                columnsToUpdate.Add("Server");

                await conn.ExecuteAsync(string.Format("insert into ApplicationStatus ({0}) values (@{1})", string.Join(",", columnsToUpdate),
                                                      string.Join(",@", columnsToUpdate)), model, tran);
            }
        }