public void Properties_Edge()
{
var props = new TestPropertyHolder();
var originalProps = new Dictionary <string, object>
{
{ string.Empty, "value1" },
{ LongPropertyName, LongText }
};
ApplicationInsightsLogger.AddProperties(props, null, null, 0, null, originalProps);
Assert.AreEqual(3, props.Properties.Count);
Assert.AreEqual(null, props.Properties["Message"]);
Assert.AreEqual("0", props.Properties["EventId"]);
Assert.IsFalse(props.Properties.ContainsKey("Title"));
var longPropName = props.Properties.Keys.FirstOrDefault(k => k.StartsWith("TooLong"));
Assert.IsTrue(!string.IsNullOrEmpty(longPropName));
Assert.IsTrue(longPropName.Length > 500);
Assert.IsFalse(longPropName.Contains("MISSINGTEXT"));
var longValue = props.Properties[longPropName];
Assert.IsTrue(!string.IsNullOrEmpty(longValue));
Assert.IsTrue(longValue.Length > 8190);
Assert.IsFalse(longValue.Contains("MISSINGTEXT"));
}
public void Properties_Common()
{
var props = new TestPropertyHolder();
var categories = new List <string> {
"c1", "c2", "c3"
};
var originalProps = new Dictionary <string, object>
{
{ "p1", 42 },
{ "p2", "value2" }
};
ApplicationInsightsLogger.AddProperties(props, "mymessage", categories, 123, "mytitle", originalProps);
// well-known properties
Assert.AreEqual("mymessage", props.Properties["Message"]);
Assert.AreEqual("mytitle", props.Properties["Title"]);
Assert.AreEqual("123", props.Properties["EventId"]);
Assert.AreEqual("c1, c2, c3", props.Properties["Categories"]);
// dynamic properties
Assert.AreEqual("42", props.Properties["p1"]);
Assert.AreEqual("value2", props.Properties["p2"]);
// overall count: null property not added
Assert.AreEqual(6, props.Properties.Count);
}
private static void Log404()
{
var logger = new ApplicationInsightsLogger("main-webpage", new TelemetryClient(), new ApplicationInsightsLoggerOptions()
{
IncludeScopes = false
});
logger.LogWarning(new EventId(2, "Request hit a 404"), "Request hit a 404");
}
private static void Log500(Exception ex)
{
var logger = new ApplicationInsightsLogger("main-webpage", new TelemetryClient(), new ApplicationInsightsLoggerOptions()
{
IncludeScopes = false
});
logger.LogError(ex, "Error in the application");
}
public void GetIpAddress_ChecksContextSecond()
{
var request = new Mock <HttpRequest>();
MockHttpRequest(request, "5.6.7.8");
string ip = ApplicationInsightsLogger.GetIpAddress(request.Object);
Assert.Equal("5.6.7.8", ip);
}
public void GetIpAddress_ChecksContextSecond()
{
HttpRequestMessage request = new HttpRequestMessage();
MockIpAddress(request, "5.6.7.8");
string ip = ApplicationInsightsLogger.GetIpAddress(request);
Assert.Equal("5.6.7.8", ip);
}
public void GetIpAddress_ChecksHeaderFirst(string headerIp)
{
HttpRequestMessage request = new HttpRequestMessage();
request.Headers.Add(ApplicationInsightsScopeKeys.ForwardedForHeaderName, headerIp);
MockIpAddress(request, "5.6.7.8");
string ip = ApplicationInsightsLogger.GetIpAddress(request);
Assert.Equal("1.2.3.4", ip);
}
public void TestLoggerWithNegativeFilterDoesNotCreateTraceTelemetryOnLoggedInfo()
{
bool trackedTelemetry = false;
TelemetryClient client = CommonMocks.MockTelemetryClient((t) => trackedTelemetry = true);
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(false); }, defaultOptions);
logger.LogInformation(0, "This is an information");
Assert.False(trackedTelemetry);
}
public void TestLoggerWithNegativeFilterDoesNotCreateExceptionTelemetryOnLoggedError()
{
bool trackedTelemetry = false;
TelemetryClient client = CommonMocks.MockTelemetryClient((t) => trackedTelemetry = true);
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(false); }, defaultOptions);
var exception = new Exception("This is an error");
logger.LogError(0, exception, "Error: " + exception.Message);
Assert.False(trackedTelemetry);
}
public void TestLoggerSetsSdkVersionOnLoggedTelemetry()
{
bool isCorrectVersion = false;
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
isCorrectVersion = t.Context.GetInternalContext().SdkVersion.StartsWith(SdkVersionUtils.VersionPrefix);
});
ILogger logger = new ApplicationInsightsLogger("test", client, (s, l) => { return(true); }, null);
logger.LogTrace("This is a test.", new object[] { });
Assert.True(isCorrectVersion);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void ConfigureProduction(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseHttpsRedirection();
app.UseCookiePolicy();
//app.UseDefaultFiles();
//app.UseStaticFiles();
app.UseExceptionHandler(errorApp =>
{
errorApp.Run(async context =>
{
try
{
Task.Run(() =>
{
var exceptionHandlerPathFeature = context.Features.Get <IExceptionHandlerPathFeature>();
var logger = new ApplicationInsightsLogger("main-webpage", new TelemetryClient(), new ApplicationInsightsLoggerOptions()
{
IncludeScopes = false
});
Log500(exceptionHandlerPathFeature.Error);
});
}
finally
{
context.Response.Redirect("https://www.cascadianaerialrobotics.com");
}
});
});
app.UseStatusCodePages(async context =>
{
if (context.HttpContext.Response.StatusCode == StatusCodes.Status404NotFound)
{
Task.Run(() => Log404());
// TODO: Issue #10 : What a fugly solution, I know, but I need to do this for the release, I'll attach the razor renderer.
await context.HttpContext.Response.WriteAsync(Http404Text);
}
});
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
public void TestLoggerCreatesTraceTelemetryOnLoggedInfo()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <TraceTelemetry>(t);
var traceTelemetry = (TraceTelemetry)t;
Assert.Equal("This is an information", traceTelemetry.Message);
Assert.Equal(SeverityLevel.Information, traceTelemetry.SeverityLevel);
Assert.Equal("test-category", traceTelemetry.Properties["CategoryName"]);
});
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, null);
logger.LogInformation(0, "This is an information");
}
public void GetIpAddress_ChecksHeaderFirst(string headerIp)
{
var request = new Mock <HttpRequest>();
var headers = new HeaderDictionary
{
{ ApplicationInsightsScopeKeys.ForwardedForHeaderName, headerIp }
};
request.SetupGet(r => r.Headers).Returns(headers);
MockHttpRequest(request, "5.6.7.8");
string ip = ApplicationInsightsLogger.GetIpAddress(request.Object);
Assert.Equal("1.2.3.4", ip);
}
public void TestLoggerCreatesExceptionTelemetryOnLoggedError()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <ExceptionTelemetry>(t);
var exceptionTelemetry = (ExceptionTelemetry)t;
Assert.Equal("Error: This is an error", exceptionTelemetry.Message);
Assert.Equal("System.Exception: This is an error", exceptionTelemetry.Properties["Exception"]);
Assert.Equal(SeverityLevel.Error, exceptionTelemetry.SeverityLevel);
});
ILogger logger = new ApplicationInsightsLogger("test", client, (s, l) => { return(true); });
var exception = new Exception("This is an error");
logger.LogError(0, exception, "Error: " + exception.Message);
}
private async Task RunAsync(CancellationToken cancellationToken)
{
ILogger logger = new ApplicationInsightsLogger();
string brokerIp;
int numberOfThreads;
try
{
brokerIp = CloudConfigurationManager.GetSetting("BrokerIp");
var threadSet = int.TryParse(CloudConfigurationManager.GetSetting("Threads"), out numberOfThreads);
if (!threadSet)
{
numberOfThreads = DefaultNumberOfThreads;
}
}
catch (Exception exception)
{
brokerIp = string.Empty;
numberOfThreads = DefaultNumberOfThreads;
logger.LogException(exception);
}
while (!cancellationToken.IsCancellationRequested)
{
try
{
var concurrentConnectonTest = new ConcurrentConnectionTest();
var concurrentConnectonTestSetup = new TestSetup(logger, brokerIp, concurrentConnectonTest, numberOfThreads);
concurrentConnectonTestSetup.RunTest(int.MaxValue, new TimeSpan(0, 60, 0), new TimeSpan(0, 0, 3), new TimeSpan(0, 0, 3), new TimeSpan(0, 0, 30), new TimeSpan(0, 1, 0));
}
catch (Exception exception)
{
logger.LogEvent("Incomplete", "Completed test using " + numberOfThreads + " threads");
logger.LogException(exception);
}
await Task.Delay(new TimeSpan(0, 1, 0));
GC.Collect();
GC.WaitForPendingFinalizers();
GC.WaitForFullGCComplete();
GC.Collect();
}
}
public void TestLoggerCreatesExceptionTelemetryOnLoggedErrorWhenTrackExceptionsAsExceptionTelemetryIsSetToTrue()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <ExceptionTelemetry>(t);
var exceptionTelemetry = (ExceptionTelemetry)t;
Assert.Equal("Error: This is an error", exceptionTelemetry.Message);
Assert.Equal(SeverityLevel.Error, exceptionTelemetry.SeverityLevel);
});
ILogger logger = new ApplicationInsightsLogger("test", client, (s, l) => { return(true); }, new ApplicationInsightsLoggerOptions {
TrackExceptionsAsExceptionTelemetry = true
});
var exception = new Exception("This is an error");
logger.LogError(0, exception, "Error: " + exception.Message);
}
public void TestLoggerCreatesTraceTelemetryWithoutEventIdOnLoggedDebug()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <TraceTelemetry>(t);
var traceTelemetry = (TraceTelemetry)t;
Assert.Equal("This is an information", traceTelemetry.Message);
Assert.Equal(SeverityLevel.Verbose, traceTelemetry.SeverityLevel);
Assert.Equal("test-category", traceTelemetry.Properties["CategoryName"]);
Assert.False(traceTelemetry.Properties.ContainsKey("EventId"));
Assert.False(traceTelemetry.Properties.ContainsKey("EventName"));
});
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, null);
logger.LogDebug(new EventId(22, "TestEvent"), "This is an information");
}
public void TestLoggerCreatesTraceTelemetryOnLoggedWarningWithParameters()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <TraceTelemetry>(t);
var traceTelemetry = (TraceTelemetry)t;
Assert.Equal("This is 123 value: Hello, World!", traceTelemetry.Message);
Assert.Equal(SeverityLevel.Warning, traceTelemetry.SeverityLevel);
Assert.Equal("test-category", traceTelemetry.Properties["CategoryName"]);
Assert.Equal("123", traceTelemetry.Properties["testParam"]);
Assert.Equal("Hello, World!", traceTelemetry.Properties["param2"]);
});
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, null);
logger.LogWarning(0, "This is {testParam} value: {param2}", 123, "Hello, World!");
}
public DatabasePoolController()
{
cacheManager = new MemoryCache();
logger = new ApplicationInsightsLogger();
if (!cacheManager.Exist(DatabaseType.Used.GetEnumDescription()).Result)
{
cacheManager.AddOrUpdate(new List <string>(), DatabaseType.Used.GetEnumDescription());
}
if (!cacheManager.Exist(DatabaseType.Open.GetEnumDescription()).Result)
{
cacheManager.AddOrUpdate(new List <string>(), DatabaseType.Open.GetEnumDescription());
}
if (!cacheManager.Exist(DatabaseType.BeingCreated.GetEnumDescription()).Result)
{
cacheManager.AddOrUpdate(new List <string>(), DatabaseType.BeingCreated.GetEnumDescription());
}
dbOperations = new AzureDbOperations();
}
public void TestLoggerCreatesExceptionWithoutEventIdTelemetryOnLoggedError()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <ExceptionTelemetry>(t);
var exceptionTelemetry = (ExceptionTelemetry)t;
Assert.Equal(SeverityLevel.Error, exceptionTelemetry.SeverityLevel);
Assert.Equal("test-category", exceptionTelemetry.Properties["CategoryName"]);
Assert.Equal("System.Exception: This is an error", exceptionTelemetry.Properties["Exception"]);
Assert.Equal("Error: This is an error", exceptionTelemetry.Message);
Assert.False(exceptionTelemetry.Properties.ContainsKey("EventId"));
Assert.False(exceptionTelemetry.Properties.ContainsKey("EventName"));
});
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, defaultOptions);
var exception = new Exception("This is an error");
logger.LogError(new EventId(22, "TestEvent"), exception, "Error: " + exception.Message);
}
public void TestLoggerCreatesExceptionTelemetryOnLoggedErrorWithParameters()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <ExceptionTelemetry>(t);
var exceptionTelemetry = (ExceptionTelemetry)t;
Assert.Equal(SeverityLevel.Error, exceptionTelemetry.SeverityLevel);
Assert.Equal("test-category", exceptionTelemetry.Properties["CategoryName"]);
Assert.Equal("System.Exception: This is an error", exceptionTelemetry.Properties["Exception"]);
Assert.Equal("Error: This is an error, Value: 123", exceptionTelemetry.Message);
Assert.Equal("This is an error", exceptionTelemetry.Properties["ex"]);
Assert.Equal("123", exceptionTelemetry.Properties["value"]);
});
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, defaultOptions);
var exception = new Exception("This is an error");
logger.LogError(0, exception, "Error: {ex}, Value: {value}", exception.Message, 123);
}
public void TestLoggerIncludingEventIdCreatesTraceTelemetryWithEventIdOnLoggedError()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <TraceTelemetry>(t);
var traceTelemetry = (TraceTelemetry)t;
Assert.Equal("This is an error", traceTelemetry.Message);
Assert.Equal(SeverityLevel.Error, traceTelemetry.SeverityLevel);
Assert.Equal("test-category", traceTelemetry.Properties["CategoryName"]);
Assert.Equal("22", traceTelemetry.Properties["EventId"]);
Assert.Equal("TestEvent", traceTelemetry.Properties["EventName"]);
});
var options = new ApplicationInsightsLoggerOptions {
IncludeEventId = true
};
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, options);
logger.LogError(new EventId(22, "TestEvent"), "This is an error");
}
public void TestLoggerIncludingEventIdCreatesTraceTelemetryWithoutEventNameOnLoggedInfo()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <TraceTelemetry>(t);
var traceTelemetry = (TraceTelemetry)t;
Assert.Equal("This is an information", traceTelemetry.Message);
Assert.Equal(SeverityLevel.Information, traceTelemetry.SeverityLevel);
Assert.Equal("test-category", traceTelemetry.Properties["CategoryName"]);
Assert.Equal("100", traceTelemetry.Properties["EventId"]);
Assert.False(traceTelemetry.Properties.ContainsKey("EventName"));
});
var options = new ApplicationInsightsLoggerOptions {
IncludeEventId = true
};
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, options);
logger.LogInformation(new EventId(100, string.Empty), "This is an information");
}
public void TestLoggerAdditionalExceptionDataIsAddedToTelemetry()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <ExceptionTelemetry>(t);
var exceptionTelemetry = (ExceptionTelemetry)t;
Assert.Equal(SeverityLevel.Error, exceptionTelemetry.SeverityLevel);
Assert.Equal("test-category", exceptionTelemetry.Properties["CategoryName"]);
Assert.Equal("System.Exception: This is an error", exceptionTelemetry.Properties["Exception"]);
Assert.Equal("Error: This is an error, Value: 123", exceptionTelemetry.Message);
Assert.Equal("test", exceptionTelemetry.Properties["AdditionalProperty1"]);
Assert.Equal("test2", exceptionTelemetry.Properties["AdditionalProperty2"]);
});
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, defaultOptions);
var exception = new Exception("This is an error");
exception.Data.Add("AdditionalProperty1", "test");
exception.Data.Add("AdditionalProperty2", "test2");
logger.LogError(0, exception, "Error: {ex}, Value: {value}", exception.Message, 123);
}
private async Task RunAsync(CancellationToken cancellationToken)
{
ILogger logger = new ApplicationInsightsLogger();
var brokerIp = CloudConfigurationManager.GetSetting("BrokerIp");
int numberOfThreads;
var threadSet = int.TryParse(CloudConfigurationManager.GetSetting("Threads"), out numberOfThreads);
if (!threadSet)
{
numberOfThreads = DefaultNumberOfThreads;
}
while (!cancellationToken.IsCancellationRequested)
{
try
{
var throughputTest = new MessageThroughputTest();
var testSetup = new TestSetup(logger, brokerIp, throughputTest, numberOfThreads);
testSetup.RunTest();
//var concurrentConnectonTest = new ConcurrentConnectionTest();
//var concurrentConnectonTestSetup = new TestSetup(logger, brokerIp, concurrentConnectonTest, numberOfThreads);
//concurrentConnectonTestSetup.RunTest(int.MaxValue, new TimeSpan(0, 10, 0), new TimeSpan(0, 1, 0), new TimeSpan(0, 1, 0));
}
catch (Exception exception)
{
logger.LogException(exception);
}
await Task.Delay(new TimeSpan(0, 0, 10));
GC.Collect();
GC.WaitForPendingFinalizers();
GC.WaitForFullGCComplete();
GC.Collect();
}
}
public void TestLoggerIncludingEventIdCreatesExceptionWithEventIdTelemetryOnLoggedErrorWithParameters()
{
TelemetryClient client = CommonMocks.MockTelemetryClient((t) =>
{
Assert.IsType <ExceptionTelemetry>(t);
var exceptionTelemetry = (ExceptionTelemetry)t;
Assert.Equal(SeverityLevel.Error, exceptionTelemetry.SeverityLevel);
Assert.Equal("test-category", exceptionTelemetry.Properties["CategoryName"]);
Assert.Equal("System.Exception: This is an error", exceptionTelemetry.Properties["Exception"]);
Assert.Equal("Error: ERROR This is an error", exceptionTelemetry.Message);
Assert.Equal("22", exceptionTelemetry.Properties["EventId"]);
Assert.Equal("ERROR", exceptionTelemetry.Properties["EventName"]);
Assert.Equal("This is an error", exceptionTelemetry.Properties["Message"]);
});
var options = new ApplicationInsightsLoggerOptions {
IncludeEventId = true
};
ILogger logger = new ApplicationInsightsLogger("test-category", client, (s, l) => { return(true); }, options);
var exception = new Exception("This is an error");
logger.LogError(new EventId(22, "TestEvent"), exception, "Error: {EventName} {Message}", "ERROR", exception.Message);
}
/// <summary>
/// Creates a new <see cref="ILog"/> instance.
/// </summary>
protected override ILog CreateLogger(string name, LogLevel level, bool showLevel, bool showDateTime, bool showLogName, string dateTimeFormat)
{
ILog log = new ApplicationInsightsLogger(instrumentationKey, name, level, showLevel, showDateTime, showLogName, dateTimeFormat);
return log;
}
/// <summary>
/// Detects the anomalies and generate alert.
/// </summary>
/// <param name="timerInfo">The timer information.</param>
/// <returns>
/// A <see cref="Task" /> representing the asynchronous operation.
/// </returns>
public static async Task ProcessAnomalyDetection([TimerTrigger("0 0 0 * * *")] TimerInfo timerInfo)
{
try
{
var alertService = new AlertService();
var meterService = new MeterService();
var requestModel = new AnomalyServiceRequest();
using (SqlConnection sqlConnection = new SqlConnection(ConfigurationSettings.DbConnectionString))
{
sqlConnection.Open();
var piServers = meterService.GetPiServerList(sqlConnection);
foreach (var piServer in piServers)
{
try
{
DateTime anomalyDetectionStartTime = piServer.PiServerCurrentDateTime.AddDays(-1).Date;
DateTime anomalyDetectionEndTime = anomalyDetectionStartTime.AddHours(24).AddSeconds(-1);
using (SqlTransaction sqlTransaction = sqlConnection.BeginTransaction())
{
var query = "SELECT PowerScout, Temperature, Timestamp, Visibility, kW_System, days, Breaker_details FROM LiveData WHERE Timestamp > @startTime AND Timestamp <= @endTime and PiServerName = @PiServerName ORDER BY Timestamp";
requestModel.GlobalParameters = new GlobalParameter();
Inputs inputs = new Inputs();
Input1 input = new Input1()
{
ColumnNames = new List <string> {
"PowerScout", "Temperature", "Timestamp", "Visibility", "kW_System", "days", "Breaker_details"
}
};
List <List <string> > values = new List <List <string> >();
using (SqlCommand selectDataCommand = new SqlCommand(query, sqlConnection, sqlTransaction))
{
selectDataCommand.Parameters.AddWithValue("@startTime", anomalyDetectionStartTime.ToString(Constants.DATE_TIME_FORMAT));
selectDataCommand.Parameters.AddWithValue("@endTime", anomalyDetectionEndTime.ToString(Constants.DATE_TIME_FORMAT));
selectDataCommand.Parameters.AddWithValue("@PiServerName", piServer.PiServerName);
using (SqlDataReader result = selectDataCommand.ExecuteReader())
{
List <string> rowValues = null;
while (result.Read())
{
rowValues = new List <string>();
rowValues.Add(SqlTypeConverter.ToString(result["PowerScout"]));
rowValues.Add(SqlTypeConverter.ToString(result["Temperature"]));
rowValues.Add(SqlTypeConverter.ToDateTime(result["Timestamp"]).ToString(Constants.DATE_TIME_FORMAT));
rowValues.Add(SqlTypeConverter.ToString(result["Visibility"]));
rowValues.Add(SqlTypeConverter.ToString(result["kW_System"]));
rowValues.Add(SqlTypeConverter.ToString(result["days"]));
rowValues.Add(SqlTypeConverter.ToString(result["Breaker_details"]));
values.Add(rowValues);
}
result.Close();
}
}
if (values.Count > 0)
{
input.Values = values;
inputs.input1 = input;
requestModel.Inputs = inputs;
var azureMLConfigurationService = new AzureMLConfigurationService();
var anomalyConfig = azureMLConfigurationService.GetAnomalyConfigData(sqlConnection, sqlTransaction);
var responseModel = await AzureMLClient.CallAzureMLAsync(requestModel, anomalyConfig.AzureMlAnomalyDetectionApiUrl, anomalyConfig.AzureMlAnomalyDetectionApiKey);
if (responseModel != null)
{
AddAnomalyToDatabase(sqlConnection, sqlTransaction, responseModel, piServer.PiServerName, anomalyDetectionStartTime, anomalyDetectionEndTime, alertService);
}
}
sqlTransaction.Commit();
}
}
catch (Exception e)
{
var errorMsg = string.Format("AnomalyDetectionJob Error : Anomaly detection failed for pi server - {0}", piServer.PiServerName);
Console.WriteLine(errorMsg);
Console.WriteLine("Error Message - {0}", e.Message);
Console.WriteLine("StackTrace - {0}", e.StackTrace);
ApplicationInsightsLogger.LogException(e, new Dictionary <string, string> {
{ "Job Error Message", errorMsg }
});
}
}
sqlConnection.Close();
}
}
catch (Exception e)
{
ApplicationInsightsLogger.LogException(e);
throw;
}
}
/// <summary>
/// Process current day consumption and predict current week electricity consumption.
/// </summary>
/// <param name="timerInfo">The timer information.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public static async Task ProcessWeeklyConsumptionPrediction([TimerTrigger("0 0/50 * * * *")] TimerInfo timerInfo)
{
try
{
var meterService = new MeterService();
using (SqlConnection sqlConnection = new SqlConnection(ConfigurationSettings.DbConnectionString))
{
sqlConnection.Open();
var piServers = meterService.GetPiServerList(sqlConnection);
foreach (var piServer in piServers)
{
try
{
DateTime today = piServer.PiServerCurrentDateTime.AddDays(-1);
int prev = (int)(today.DayOfWeek - 1);
int next = (int)(7 - today.DayOfWeek);
var rowModified = 0;
using (SqlTransaction sqlTransaction = sqlConnection.BeginTransaction())
{
var powerScouts = meterService.GetMeterListByPiServer(sqlConnection, sqlTransaction, piServer.PiServerName);
foreach (var powerScout in powerScouts)
{
double weeklyPredictedKWH = 0;
var dailyConsumptionDetails = meterService.GetTodaysDailyConsumptionDetails(sqlConnection, sqlTransaction, powerScout, piServer);
if (dailyConsumptionDetails != null)
{
DateTime initialDate = dailyConsumptionDetails.Timestamp;
if (prev > 0)
{
for (int i = 1; i <= prev; i++)
{
dailyConsumptionDetails.Timestamp = today.AddDays(-i);
var response = await meterService.GetAnomalyPrediction(dailyConsumptionDetails, sqlConnection, sqlTransaction, piServer.PiServerName, false);
if (response != null)
{
List <string> columnNames = response.Results.Output1.Value.ColumnNames.ToList();
weeklyPredictedKWH += Convert.ToDouble(response.Results.Output1.Value.Values[0][columnNames.IndexOf("Scored Labels")]);
}
}
}
for (int i = 0; i <= next; i++)
{
dailyConsumptionDetails.Timestamp = today.AddDays(i);
var response = await meterService.GetAnomalyPrediction(dailyConsumptionDetails, sqlConnection, sqlTransaction, piServer.PiServerName, false);
if (response != null)
{
List <string> columnNames = response.Results.Output1.Value.ColumnNames.ToList();
weeklyPredictedKWH += Convert.ToDouble(response.Results.Output1.Value.Values[0][columnNames.IndexOf("Scored Labels")]);
}
}
if (weeklyPredictedKWH != 0)
{
var weeklyConsumptionPrediction = new WeeklyConsumptionPrediction();
weeklyConsumptionPrediction.Start_Time = today.AddDays(-prev).Date;
weeklyConsumptionPrediction.End_Time = today.AddDays(next).Date;
weeklyConsumptionPrediction.PowerScout = powerScout;
weeklyConsumptionPrediction.Breaker_details = dailyConsumptionDetails.Breaker_details;
weeklyConsumptionPrediction.Weekly_Predicted_KWH_System = weeklyPredictedKWH;
weeklyConsumptionPrediction.Building = dailyConsumptionDetails.Building;
SaveWeeklyPrediction(weeklyConsumptionPrediction, sqlConnection, sqlTransaction, piServer.PiServerName);
rowModified++;
}
}
}
sqlTransaction.Commit();
}
Console.WriteLine("WeeklyConsumptionPredictionJob Insert/Update - PiServer - {0}, Rows {1}", piServer.PiServerName, rowModified);
}
catch (Exception e)
{
var errorMsg = string.Format("WeeklyConsumptionPredictionJob Error : Weekly consumption failed for PiServer - {0}", piServer.PiServerName);
Console.WriteLine(errorMsg);
Console.WriteLine("Error Message - {0}", e.Message);
Console.WriteLine("StackTrace - {0}", e.StackTrace);
ApplicationInsightsLogger.LogException(e, new Dictionary <string, string> {
{ "Job Error Message", errorMsg }
});
}
}
sqlConnection.Close();
}
}
catch (Exception e)
{
ApplicationInsightsLogger.LogException(e);
throw;
}
}
/// <summary>
/// Process electricity consumption to generate recommendation for power saving.
/// </summary>
/// <param name="timerInfo">The timer information.</param>
public static void ProcessConsumptionAlert([TimerTrigger("0 0 0 * * *")] TimerInfo timerInfo)
{
try
{
var meterService = new MeterService();
using (SqlConnection sqlConnection = new SqlConnection(ConfigurationSettings.DbConnectionString))
{
sqlConnection.Open();
var piServers = meterService.GetPiServerList(sqlConnection);
foreach (var piServer in piServers)
{
try
{
DateTime prevWeekDay = piServer.PiServerCurrentDateTime.Date.AddDays(-1);
DateTime lastWeekendSunday = prevWeekDay.AddDays(-(int)prevWeekDay.DayOfWeek);
// if today is weekend(saturday) move back to Friday.
if (prevWeekDay.DayOfWeek == DayOfWeek.Saturday)
{
prevWeekDay = prevWeekDay.AddDays(-1);
lastWeekendSunday = prevWeekDay.AddDays(-5);
}
// if today is weekend(sunday) move back to Friday.
else if (prevWeekDay.DayOfWeek == DayOfWeek.Sunday)
{
prevWeekDay = prevWeekDay.AddDays(-2);
lastWeekendSunday = prevWeekDay.AddDays(-5);
}
// Weekend Logic
DateTime lastWeekendSaturday = lastWeekendSunday.AddDays(-1);
List <DateTime> lastWeekendDays = new List <DateTime>();
lastWeekendDays.Add(lastWeekendSaturday);
lastWeekendDays.Add(lastWeekendSunday);
using (SqlTransaction sqlTransaction = sqlConnection.BeginTransaction())
{
long nonWorkingHourWeekendConsumption = 0;
foreach (var day in lastWeekendDays)
{
DateTime startdayTime = day.AddHours(5);
DateTime endDayTime = startdayTime.AddHours(24).AddSeconds(-1);
DayConsumptionInfo info = GetConsumption(startdayTime, endDayTime, sqlConnection, sqlTransaction, piServer.PiServerName);
nonWorkingHourWeekendConsumption += info.NonWorkingHourConsumption;
}
if (nonWorkingHourWeekendConsumption > 0)
{
long weekendConsumption = (nonWorkingHourWeekendConsumption / 2) * 52; // here 52 is for weeks in a year
GenerateConsumptionAlertAndNotification(sqlConnection, sqlTransaction, weekendConsumption, piServer);
}
// Previous Week Day Logic
DateTime startTime = prevWeekDay.AddHours(5);
DateTime endTime = startTime.AddHours(24).AddSeconds(-1);
DayConsumptionInfo weekDayInfo = GetConsumption(startTime, endTime, sqlConnection, sqlTransaction, piServer.PiServerName);
if (weekDayInfo.NonWorkingHourConsumption > 0)
{
long weekdayConsumption = (weekDayInfo.NonWorkingHourConsumption / 2) * 365;
GenerateConsumptionAlertAndNotification(sqlConnection, sqlTransaction, weekdayConsumption, piServer, false);
}
sqlTransaction.Commit();
}
}
catch (Exception e)
{
var errorMsg = string.Format("ConsumptionAlertJob Error : Consumption alert failed for pi server - {0}", piServer.PiServerName);
Console.WriteLine(errorMsg);
Console.WriteLine("Error Message - {0}", e.Message);
Console.WriteLine("StackTrace - {0}", e.StackTrace);
ApplicationInsightsLogger.LogException(e, new Dictionary <string, string> {
{ "Job Error Message", errorMsg }
});
}
}
sqlConnection.Close();
}
}
catch (Exception e)
{
ApplicationInsightsLogger.LogException(e);
throw;
}
}
public void TestUninitializedLoggerDoesNotThrowExceptions()
{
ILogger logger = new ApplicationInsightsLogger("test", null, null, null);
logger.LogTrace("This won't do anything.", new object[] { });
}
