private void ExecuteRestrictedToMinimumLevelTest(string logGroupName)
{
// Log 4 Debug messages
for (int i = 0; i < 3; i++)
{
Log.Debug(string.Format("Test logging message {0} SeriLog, Thread Id:{1}", i, Thread.CurrentThread.ManagedThreadId));
}
// Log 5 Error messages
for (int i = 0; i < 5; i++)
{
Log.Error(string.Format("Test logging message {0} SeriLog, Thread Id:{1}", i, Thread.CurrentThread.ManagedThreadId));
}
Log.Error(LASTMESSAGE);
GetLogEventsResponse getLogEventsResponse = new GetLogEventsResponse();
if (NotifyLoggingCompleted("AWSSeriLogGroupRestrictedtoMinimumLevel", "LASTMESSAGE"))
{
DescribeLogStreamsResponse describeLogstreamsResponse = Client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
getLogEventsResponse = Client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
}
Assert.Equal(6, getLogEventsResponse.Events.Count);
}
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
GetLogEventsResponse response = new GetLogEventsResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("events", targetDepth))
{
var unmarshaller = new ListUnmarshaller <OutputLogEvent, OutputLogEventUnmarshaller>(OutputLogEventUnmarshaller.Instance);
response.Events = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("nextBackwardToken", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.NextBackwardToken = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("nextForwardToken", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.NextForwardToken = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
public void Log4Net()
{
XmlConfigurator.Configure(new System.IO.FileInfo("log4net.config"));
logger = LogManager.GetLogger("Log4Net");
for (int i = 0; i < 10; i++)
{
logger.Debug(string.Format("Test logging message {0} Log4Net", i));
}
//Added Sleep to give sufficient time for the log stream to get posted on CloudWatch
Thread.Sleep(10000);
string region = "us-west-2";
string logGroupName = "AWSLog4NetGroupLog4Net";
AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient(
Amazon.RegionEndpoint.GetBySystemName(region));
DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
Assert.Equal(10, getLogEventsResponse.Events.Count());
}
static void dumpevts(GetLogEventsResponse r)
{
foreach (var evt in r.Events)
{
Console.WriteLine($"{evt.Timestamp}: ${evt.Message}");
}
}
public async Task GetLogEventsTest_TwoResponses()
{
var request = new GetLogEventsRequest();
var firstResponse = new GetLogEventsResponse()
{
NextForwardToken = "foo"
};
var secondResponse = new GetLogEventsResponse()
{
NextForwardToken = null
};
var token = new CancellationToken();
_mockClient.SetupSequence(x => x.GetLogEventsAsync(It.IsAny <GetLogEventsRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(firstResponse)
.ReturnsAsync(secondResponse);
var numResponses = 0;
await foreach (var desination in _mockClient.Object.Paginators.GetLogEvents(request).Responses.WithCancellation(token))
{
numResponses += 1;
}
Assert.Equal(2, numResponses);
}
public void SimpleLoggingTest(string logGroupName)
{
LogMessages(SIMPLELOGTEST_COUNT);
GetLogEventsResponse getLogEventsResponse = new GetLogEventsResponse();
if (NotifyLoggingCompleted(logGroupName, "LASTMESSAGE"))
{
DescribeLogStreamsResponse describeLogstreamsResponse =
Client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
getLogEventsResponse = Client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
var customStreamSuffix = describeLogstreamsResponse.LogStreams[0].LogStreamName.Split('-').Last().Trim();
Assert.Equal(CUSTOMSTREAMSUFFIX, customStreamSuffix);
}
Assert.Equal(SIMPLELOGTEST_COUNT, getLogEventsResponse.Events.Count());
_testFixture.LogGroupNameList.Add(logGroupName);
}
public void MessageHasToBeBrokenUp()
{
string logGroupName = "AWSNLogGroupEventSizeExceededTest";
CreateLoggerFromConfiguration("AWSNLogGroupEventSizeExceededTest.config");
Logger = LogManager.GetLogger("loggerRegularEventSizeExceeded");
// This will get broken up into 3 CloudWatch Log messages
Logger.Debug(new string('a', 600000));
Logger.Debug(LASTMESSAGE);
GetLogEventsResponse getLogEventsResponse = new GetLogEventsResponse();
if (NotifyLoggingCompleted(logGroupName, "LASTMESSAGE"))
{
DescribeLogStreamsResponse describeLogstreamsResponse =
Client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
// Wait for the large messages to propagate
Thread.Sleep(5000);
getLogEventsResponse = Client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
}
_testFixture.LogGroupNameList.Add(logGroupName);
Assert.Equal(4, getLogEventsResponse.Events.Count());
}
public void ILogger()
{
LoggerConfigSectionSetup("appsettings.json", null);
var logger = LoggerSetup();
for (int i = 0; i < 10; i++)
{
logger.LogDebug(string.Format("Test logging message {0} Ilogger", i));
}
//Sleep is introduced to give suffiecient time for the logstream to get posted on CloudWatchLogs
Thread.Sleep(5000);
string region = _configSection.Config.Region;
string logGroupName = _configSection.Config.LogGroup;
AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient(
Amazon.RegionEndpoint.GetBySystemName(region));
DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
Assert.Equal(10, getLogEventsResponse.Events.Count());
}
public void MultiThreadTest(string logGroupName)
{
var tasks = new List <Task>();
var streamNames = new List <string>();
var count = MULTITHREADTEST_COUNT;
var totalCount = 0;
for (int i = 0; i < THREAD_COUNT; i++)
{
tasks.Add(Task.Factory.StartNew(() => LogMessages(count)));
totalCount = totalCount + count;
}
Task.WaitAll(tasks.ToArray(), TimeSpan.FromSeconds(THREAD_WAITTIME));
int testCount = -1;
if (NotifyLoggingCompleted(logGroupName, "LASTMESSAGE"))
{
DescribeLogStreamsResponse describeLogstreamsResponse =
Client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
if (describeLogstreamsResponse.LogStreams.Count > 0)
{
testCount = 0;
foreach (var logStream in describeLogstreamsResponse.LogStreams)
{
GetLogEventsResponse getLogEventsResponse =
Client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = logStream.LogStreamName
}).Result;
if (getLogEventsResponse != null)
{
testCount += getLogEventsResponse.Events.Count();
}
}
}
}
Assert.Equal(totalCount, testCount);
_testFixture.LogGroupNameList.Add(logGroupName);
}
public void MultiThreadTest()
{
global::NLog.Logger logger;
try
{
LogManager.Configuration = new XmlLoggingConfiguration("Regular.config");
}
catch (FileNotFoundException)
{
LogManager.Configuration = new XmlLoggingConfiguration("./test/AWS.Logger.NLog.Tests/Regular.config");
}
logger = LogManager.GetLogger("loggerMultiThread");
var tasks = new List <Task>();
var streamNames = new List <string>();
var count = 200;
var totcount = 0;
for (int i = 0; i < 2; i++)
{
tasks.Add(Task.Factory.StartNew(() => NLogThread(count, logger)));
totcount = totcount + count;
}
Task.WaitAll(tasks.ToArray());
Thread.Sleep(10000);
string region = "us-west-2";
string logGroupName = "AWSNLogGroupMultiThreadTest";
AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient(
Amazon.RegionEndpoint.GetBySystemName(region));
DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
Assert.Equal(totcount, getLogEventsResponse.Events.Count());
}
public async Task GetLogEventsTest__OnlyUsedOnce()
{
var request = new GetLogEventsRequest();
var response = new GetLogEventsResponse();
var token = new CancellationToken();
var paginator = _mockClient.Object.Paginators.GetLogEvents(request);
_mockClient.Setup(x => x.GetLogEventsAsync(It.IsAny <GetLogEventsRequest>(), It.IsAny <CancellationToken>())).ReturnsAsync(response);
// Should work the first time
await LoopOverGetLogEvents(paginator, token);
// Second time should throw an exception
await Assert.ThrowsAsync <System.InvalidOperationException>(async() => await LoopOverGetLogEvents(paginator, token));
}
public void MultiThreadTest()
{
ILog logger;
XmlConfigurator.Configure(new System.IO.FileInfo("log4net.config"));
logger = LogManager.GetLogger("MultiThreadTest");
var log = LogManager.GetCurrentLoggers();
var tasks = new List <Task>();
var count = 200;
var totcount = 0;
for (int i = 0; i < 2; i++)
{
tasks.Add(Task.Factory.StartNew(() => Log4NetThread(count, logger)));
totcount = totcount + count;
}
Task.WaitAll(tasks.ToArray(), 10000);
//Added Sleep to give sufficient time for the log stream to get posted on CloudWatch
Thread.Sleep(5000);
string region = "us-west-2";
string logGroupName = "AWSLog4NetGroupLog4NetMultiThreadTest";
AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient(
Amazon.RegionEndpoint.GetBySystemName(region));
DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
Assert.Equal(totcount, getLogEventsResponse.Events.Count());
}
public void MultiThreadTest()
{
var tasks = new List <Task>();
var streamNames = new List <string>();
ILoggerMultiThreadTestSetup("appsettings.json");
logger = ILoggerTest.LoggerSetup();
var count = 200;
var totcount = 0;
for (int i = 0; i < 2; i++)
{
tasks.Add(Task.Factory.StartNew(() => ILoggerThread(count)));
totcount = totcount + count;
}
Task.WaitAll(tasks.ToArray(), 10000);
//Sleep is introduced to give suffiecient time for the logstream to get posted on CloudWatchLogs
Thread.Sleep(5000);
string region = ILoggerTest._configSection.Config.Region;
string logGroupName = ILoggerTest._configSection.Config.LogGroup;
AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient(
Amazon.RegionEndpoint.GetBySystemName(region));
DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
Assert.Equal(totcount, getLogEventsResponse.Events.Count());
}
public void Nlog()
{
try
{
LogManager.Configuration = new XmlLoggingConfiguration("Regular.config");
}
catch (FileNotFoundException)
{
LogManager.Configuration = new XmlLoggingConfiguration("./test/AWS.Logger.NLog.Tests/Regular.config");
}
global::NLog.Logger logger = LogManager.GetLogger("loggerRegular");
for (int i = 0; i < 10; i++)
{
logger.Debug(string.Format("Test logging message {0} NLog, Thread Id:{1}", i, Thread.CurrentThread.ManagedThreadId));
}
string region = "us-west-2";
string logGroupName = "AWSNLogGroup";
Thread.Sleep(10000);
AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient(
Amazon.RegionEndpoint.GetBySystemName(region));
DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
Descending = true,
LogGroupName = logGroupName,
OrderBy = "LastEventTime"
}).Result;
GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName
}).Result;
Assert.Equal(10, getLogEventsResponse.Events.Count());
}
public async Task GetLogEventsTest__CancellationToken()
{
var request = new GetLogEventsRequest();
var firstResponse = new GetLogEventsResponse()
{
NextForwardToken = "foo"
};
var secondResponse = new GetLogEventsResponse()
{
NextForwardToken = null
};
var paginator = _mockClient.Object.Paginators.GetLogEvents(request);
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
tokenSource.Cancel();
_mockClient.SetupSequence(x => x.GetLogEventsAsync(It.IsAny <GetLogEventsRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(firstResponse)
.ReturnsAsync(secondResponse);
await Assert.ThrowsAsync <OperationCanceledException>(async() => await LoopOverGetLogEvents(paginator, token));
}
public void CRUDLogGroup()
{
var logGroupName = "sdk-dotnet-" + DateTime.Now.Ticks;
Client.CreateLogGroupAsync(new CreateLogGroupRequest
{
LogGroupName = logGroupName
}).Wait();
try
{
{
DescribeLogGroupsResponse response = Client.DescribeLogGroupsAsync(new DescribeLogGroupsRequest
{
LogGroupNamePrefix = logGroupName
}).Result;
Assert.AreEqual(1, response.LogGroups.Count);
Assert.IsNotNull(response.LogGroups[0].Arn);
Assert.IsNull(response.LogGroups[0].RetentionInDays);
Client.PutRetentionPolicyAsync(new PutRetentionPolicyRequest
{
LogGroupName = logGroupName,
RetentionInDays = 1
}).Wait();
response = Client.DescribeLogGroupsAsync(new DescribeLogGroupsRequest
{
LogGroupNamePrefix = logGroupName
}).Result;
Assert.AreEqual(1, response.LogGroups.Count);
Assert.AreEqual(1, response.LogGroups[0].RetentionInDays.GetValueOrDefault());
}
{
Client.CreateLogStreamAsync(new CreateLogStreamRequest
{
LogGroupName = logGroupName,
LogStreamName = "sample"
}).Wait();
DescribeLogStreamsResponse describeResponse = Client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest
{
LogGroupName = logGroupName,
LogStreamNamePrefix = "sample"
}).Result;
Assert.AreEqual(1, describeResponse.LogStreams.Count);
Assert.IsNotNull(describeResponse.LogStreams[0].Arn);
PutLogEventsResponse putResponse1 = Client.PutLogEventsAsync(new PutLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = "sample",
LogEvents = new List <InputLogEvent>
{
new InputLogEvent
{
Message = "First Data",
Timestamp = DateTime.Now
}
}
}).Result;
// Pad the time so the 2 events are not at the same time.
UtilityMethods.Sleep(TimeSpan.FromSeconds(.1));
Client.PutLogEventsAsync(new PutLogEventsRequest
{
SequenceToken = putResponse1.NextSequenceToken,
LogGroupName = logGroupName,
LogStreamName = "sample",
LogEvents = new List <InputLogEvent>
{
new InputLogEvent
{
Message = "Second Data",
Timestamp = DateTime.Now
}
}
}).Wait();
GetLogEventsResponse getResponse = null;
// Doing this in a loop to wait for the eventual consistency of the events
// being written to cloudwatch logs.
for (int i = 0; i < 20; i++)
{
getResponse = Client.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = "sample",
StartTime = DateTime.Now.AddDays(-2),
EndTime = DateTime.Now
}).Result;
if (getResponse.Events.Count == 2)
{
break;
}
UtilityMethods.Sleep(TimeSpan.FromSeconds(2));
}
Assert.AreEqual(2, getResponse.Events.Count);
Assert.AreEqual("First Data", getResponse.Events[0].Message);
Assert.AreEqual(DateTime.UtcNow.Date, getResponse.Events[0].Timestamp.Date);
Assert.AreEqual("Second Data", getResponse.Events[1].Message);
Assert.AreEqual(DateTime.UtcNow.Date, getResponse.Events[1].Timestamp.Date);
Assert.IsTrue(getResponse.Events[0].Timestamp < getResponse.Events[1].Timestamp);
Client.DeleteLogStreamAsync(new DeleteLogStreamRequest
{
LogGroupName = logGroupName,
LogStreamName = "sample"
}).Wait();
}
}
finally
{
Client.DeleteLogGroupAsync(new DeleteLogGroupRequest
{
LogGroupName = logGroupName
}).Wait();
}
}
public async Task <IActionResult> Index(string StreamID, string ViewMode)
{
if (_context.VPCs.ToList().Count == 0)
{
ViewData["MissingVPC"] = "YES";
}
if (StreamID == null)
{
PlatformLogsParentViewModel model = new PlatformLogsParentViewModel
{
Response = null,
Streams = _context.CloudWatchLogStreams.ToList(),
SelectedValue = 0
};
TempData["Exception"] = "Invaild Selection of Component!";
return(View(model));
}
else if (StreamID.Equals("0"))
{
List <RDSSQLLog> Logs = _context.GetRDSLogs().Result.ToList();
PlatformLogsParentViewModel model = new PlatformLogsParentViewModel
{
Response = null,
Streams = _context.CloudWatchLogStreams.ToList(),
SelectedValue = int.Parse(StreamID),
SQLlogs = Logs
};
if (ViewMode.Equals("Automatic"))
{
ViewData["Mode"] = "Automatic";
}
else if (ViewMode.Equals("Generic"))
{
ViewData["Mode"] = "Automatic";
}
return(View(model));
}
else if (ViewMode.Equals("Automatic"))
{
CloudWatchLogStream selectedStream = await _context.CloudWatchLogStreams.FindAsync(int.Parse(StreamID));
if (selectedStream != null)
{
GetLogEventsResponse response = await CloudwatchLogsClient.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = selectedStream.LinkedGroup.Name.Replace("@", "/"),
LogStreamName = selectedStream.Name
});
PlatformLogsParentViewModel model = new PlatformLogsParentViewModel
{
Streams = _context.CloudWatchLogStreams.ToList(),
SelectedValue = int.Parse(StreamID)
};
if (selectedStream.DisplayName.Contains("IIS"))
{
List <IISLog> logs = new List <IISLog>();
foreach (OutputLogEvent e in response.Events)
{
if (!e.Message.StartsWith('#'))
{
string[] spiltedRecord = e.Message.Split();
IISLog l = new IISLog
{
TimeStamp = e.Timestamp.ToLocalTime(),
ServerIP = spiltedRecord[0],
HTTPMethod = spiltedRecord[1],
Path = spiltedRecord[2],
Query = spiltedRecord[3],
DestPort = int.Parse(spiltedRecord[4]),
AuthenticatedUser = spiltedRecord[5],
SourceIP = spiltedRecord[6],
SourceUserAgent = spiltedRecord[7],
Referer = spiltedRecord[8],
HTTPStatusCode = int.Parse(spiltedRecord[9]),
SubstatusCode = int.Parse(spiltedRecord[10]),
Win32StatusCode = int.Parse(spiltedRecord[11]),
Duration = int.Parse(spiltedRecord[12]),
};
logs.Add(l);
}
}
model.IISLogs = logs;
}
else if (selectedStream.DisplayName.Contains("eni"))
{
List <ENILog> logs = new List <ENILog>();
foreach (OutputLogEvent e in response.Events)
{
if (!e.Message.Contains("NODATA"))
{
string[] spiltedRecord = e.Message.Split();
ENILog l = new ENILog
{
TimeStamp = e.Timestamp.ToLocalTime(),
Version = int.Parse(spiltedRecord[0]),
AccountID = long.Parse(spiltedRecord[1]),
Interface = spiltedRecord[2],
SourceAddress = spiltedRecord[3],
DestinationAddress = spiltedRecord[4],
SourcePort = spiltedRecord[5],
DestinationPort = spiltedRecord[6],
Packets = int.Parse(spiltedRecord[8]),
Bytes = int.Parse(spiltedRecord[9]),
StartTime = long.Parse(spiltedRecord[10]),
EndTime = long.Parse(spiltedRecord[11]),
Action = spiltedRecord[12],
LogAction = spiltedRecord[13]
};
if (spiltedRecord[7].Equals("1"))
{
l.Protocol = "ICMP";
}
else if (spiltedRecord[7].Equals("4"))
{
l.Protocol = "IPv4";
}
else if (spiltedRecord[7].Equals("6"))
{
l.Protocol = "TCP";
}
else if (spiltedRecord[7].Equals("17"))
{
l.Protocol = "UDP";
}
else if (spiltedRecord[7].Equals("41"))
{
l.Protocol = "IPv6";
}
logs.Add(l);
}
}
model.ENILogs = logs;
}
else
{
foreach (OutputLogEvent e in response.Events)
{
e.Timestamp = e.Timestamp.ToLocalTime();
}
model.Response = response;
}
ViewData["Mode"] = "Automatic";
return(View(model));
}
else
{
return(NotFound());
}
}
else
{
CloudWatchLogStream selectedStream = await _context.CloudWatchLogStreams.FindAsync(int.Parse(StreamID));
if (selectedStream != null)
{
GetLogEventsResponse response = await CloudwatchLogsClient.GetLogEventsAsync(new GetLogEventsRequest
{
LogGroupName = selectedStream.LinkedGroup.Name.Replace("@", "/"),
LogStreamName = selectedStream.Name
});
foreach (OutputLogEvent e in response.Events)
{
e.Timestamp = e.Timestamp.ToLocalTime();
}
PlatformLogsParentViewModel model = new PlatformLogsParentViewModel
{
Response = response,
Streams = _context.CloudWatchLogStreams.ToList(),
SelectedValue = int.Parse(StreamID)
};
ViewData["Mode"] = "Generic";
return(View(model));
}
else
{
return(NotFound());
}
}
}
