protected virtual async Task GetSequenceTokenAsync(string logStreamName, bool createStreamIfNotExists)
{
// Failover
if (_failoverSinkEnabled)
{
// Failover to Secondary Region
_ = FailOverToSecondaryRegion(_throttle);
}
try
{
var request = new DescribeLogStreamsRequest
{
LogGroupName = _logGroupName,
LogStreamNamePrefix = logStreamName
};
DescribeLogStreamsResponse describeLogsStreamsResponse = null;
try
{
describeLogsStreamsResponse = await CloudWatchLogsClient.DescribeLogStreamsAsync(request);
}
catch (ResourceNotFoundException rex)
{
// Create the log group if it doesn't exist.
if (rex.Message.IndexOf("log group does not exist") > -1)
{
_logger?.LogInformation("Log group {0} does not exist. Creating it.", _logGroupName);
await CreateLogGroupAsync();
if (createStreamIfNotExists)
{
await CreateLogStreamAsync(logStreamName);
}
return;
}
}
var logStream = describeLogsStreamsResponse.LogStreams
.FirstOrDefault(s => s.LogStreamName.Equals(logStreamName, StringComparison.CurrentCultureIgnoreCase));
if (logStream == null)
{
if (createStreamIfNotExists)
{
await CreateLogStreamAsync(logStreamName);
}
}
else
{
_sequenceToken = logStream.UploadSequenceToken;
}
}
catch (Exception)
{
// Set error count
_throttle.SetError();
throw;
}
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeLogStreams operation.
/// <seealso cref="Amazon.CloudWatchLogs.IAmazonCloudWatchLogs"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DescribeLogStreams operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <DescribeLogStreamsResponse> DescribeLogStreamsAsync(DescribeLogStreamsRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DescribeLogStreamsRequestMarshaller();
var unmarshaller = DescribeLogStreamsResponseUnmarshaller.Instance;
return(Invoke <IRequest, DescribeLogStreamsRequest, DescribeLogStreamsResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
public async Task DeleteCloudWatchLogStreamsForLogStreams(string logGroupName)
{
try
{
var client = new AmazonCloudWatchLogsClient(AwsCredentials, Region);
var logStreamRequest = new DescribeLogStreamsRequest()
{
LogGroupName = logGroupName,
OrderBy = OrderBy.LastEventTime
};
var logStreamsResponse = await client.DescribeLogStreamsAsync(logStreamRequest); // rate limit is 5 per second
foreach (var stream in logStreamsResponse.LogStreams)
{
var request = new DeleteLogStreamRequest(logGroupName, stream.LogStreamName);
var deleteLogStringresponse = await client.DeleteLogStreamAsync(request);
Thread.Sleep(150);
}
}
catch (Exception ex)
{
throw ex;
}
}
private async void PutLog(string groupName, string streamName, string msg)
{
try
{
var req = new DescribeLogStreamsRequest(groupName)
{
LogStreamNamePrefix = streamName
};
var resp = await _logsClient.DescribeLogStreamsAsync(req);
var token = resp.LogStreams.FirstOrDefault(s => s.LogStreamName == streamName)?.UploadSequenceToken;
var ie = new InputLogEvent
{
Message = msg,
Timestamp = DateTime.UtcNow
};
var request = new PutLogEventsRequest(groupName, streamName, new List <InputLogEvent> {
ie
});
if (!string.IsNullOrEmpty(token))
{
request.SequenceToken = token;
}
await _logsClient.PutLogEventsAsync(request);
}
catch (Exception e)
{
// ignored
}
}
public async Task DescribeLogStreamsTest_TwoResponses()
{
var request = new DescribeLogStreamsRequest();
var firstResponse = new DescribeLogStreamsResponse()
{
NextToken = "foo"
};
var secondResponse = new DescribeLogStreamsResponse()
{
NextToken = null
};
var token = new CancellationToken();
_mockClient.SetupSequence(x => x.DescribeLogStreamsAsync(It.IsAny <DescribeLogStreamsRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(firstResponse)
.ReturnsAsync(secondResponse);
var numResponses = 0;
await foreach (var desination in _mockClient.Object.Paginators.DescribeLogStreams(request).Responses.WithCancellation(token))
{
numResponses += 1;
}
Assert.Equal(2, numResponses);
}
internal DescribeLogStreamsResponse DescribeLogStreams(DescribeLogStreamsRequest request)
{
var marshaller = new DescribeLogStreamsRequestMarshaller();
var unmarshaller = DescribeLogStreamsResponseUnmarshaller.Instance;
return(Invoke <DescribeLogStreamsRequest, DescribeLogStreamsResponse>(request, marshaller, unmarshaller));
}
public async Task <List <string> > GetCloudWatchEventMessagesForLogGroup(string logGroupName, DateTime startTime)
{
var result = new List <string>();
var stopWatch = new Stopwatch();
try
{
var client = new AmazonCloudWatchLogsClient(AwsCredentials, Region);
var logStreamRequest = new DescribeLogStreamsRequest()
{
LogGroupName = logGroupName,
OrderBy = OrderBy.LastEventTime
};
stopWatch.Start();
while (stopWatch.ElapsedMilliseconds < TimeSpan.FromMinutes(1).TotalMilliseconds)
{
var logStreamsResponse = await client.DescribeLogStreamsAsync(logStreamRequest); // rate limit is 5 per second
foreach (var stream in logStreamsResponse.LogStreams)
{
var logEventsRequest = new GetLogEventsRequest()
{
LogGroupName = logGroupName,
LogStreamName = stream.LogStreamName,
StartTime = startTime,
};
var logEventsResponse = await client.GetLogEventsAsync(logEventsRequest); // rate limit is 10 per second
result.AddRange(logEventsResponse.Events.Select(e => e.Message).ToList());
Thread.Sleep(150);
}
if (result.Count > 0)
{
var nrLog = result.Where(l => l.Contains(NRLogIdentifier));
if (nrLog?.Count() > 0)
{
break;
}
}
Thread.Sleep(250);
}
}
catch (Exception e)
{
throw e;
}
stopWatch.Stop();
return(result);
}
/// <summary>
/// Updates the log stream sequence token.
/// </summary>
/// <exception cref="Serilog.Sinks.AwsCloudWatch.AwsCloudWatchSinkException"></exception>
private async Task UpdateLogStreamSequenceTokenAsync()
{
DescribeLogStreamsRequest describeLogStreamsRequest = new DescribeLogStreamsRequest
{
LogGroupName = options.LogGroupName,
LogStreamNamePrefix = logStreamName
};
var describeLogStreamsResponse = await cloudWatchClient.DescribeLogStreamsAsync(describeLogStreamsRequest);
nextSequenceToken = describeLogStreamsResponse.NextToken;
}
private async Task <string> GetLatestLogStream(string logGroup)
{
var request = new DescribeLogStreamsRequest
{
LogGroupName = logGroup
};
var response = await _client.DescribeLogStreamsAsync(request);
return(response.LogStreams.FirstOrDefault()?.LogStreamName);
}
internal DescribeLogStreamsResponse DescribeLogStreams(DescribeLogStreamsRequest request)
{
var task = DescribeLogStreamsAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
public async Task DescribeLogStreamsTest__OnlyUsedOnce()
{
var request = new DescribeLogStreamsRequest();
var response = new DescribeLogStreamsResponse();
var token = new CancellationToken();
var paginator = _mockClient.Object.Paginators.DescribeLogStreams(request);
_mockClient.Setup(x => x.DescribeLogStreamsAsync(It.IsAny <DescribeLogStreamsRequest>(), It.IsAny <CancellationToken>())).ReturnsAsync(response);
// Should work the first time
await LoopOverLogStreams(paginator, token);
// Second time should throw an exception
await Assert.ThrowsAsync <System.InvalidOperationException>(async() => await LoopOverLogStreams(paginator, token));
}
/// <summary>
/// Attempts to get the log stream defined by <see cref="logStreamName"/>.
/// </summary>
/// <returns>The matching log stream or null if no match can be found.</returns>
private async Task <LogStream> GetLogStreamAsync()
{
var describeLogStreamsRequest = new DescribeLogStreamsRequest
{
LogGroupName = options.LogGroupName,
LogStreamNamePrefix = logStreamName
};
var describeLogStreamsResponse = await cloudWatchClient
.DescribeLogStreamsAsync(describeLogStreamsRequest);
return(describeLogStreamsResponse
.LogStreams
.SingleOrDefault(ls => string.Equals(ls.LogStreamName, logStreamName, StringComparison.Ordinal)));
}
private async Task GetSequenceTokenAsync(string logStreamName, bool createStreamIfNotExists)
{
var request = new DescribeLogStreamsRequest
{
LogGroupName = _logGroupName,
LogStreamNamePrefix = logStreamName
};
DescribeLogStreamsResponse describeLogsStreamsResponse = null;
try
{
describeLogsStreamsResponse = await _client.DescribeLogStreamsAsync(request);
}
catch (ResourceNotFoundException rex)
{
// Create the log group if it doesn't exist.
if (rex.Message.IndexOf("log group does not exist") > -1)
{
_logger?.LogInformation("Log group {0} does not exist. Creating it.", _logGroupName);
await this.CreateLogGroupAsync();
if (createStreamIfNotExists)
{
await this.CreateLogStreamAsync(logStreamName);
}
return;
}
}
var logStream = describeLogsStreamsResponse.LogStreams
.FirstOrDefault(s => s.LogStreamName.Equals(logStreamName, StringComparison.CurrentCultureIgnoreCase));
if (logStream == null)
{
if (createStreamIfNotExists)
{
await this.CreateLogStreamAsync(logStreamName);
}
}
else
{
_sequenceToken = logStream.UploadSequenceToken;
}
}
private async Task GetSequenceTokenAsync(string logGroup, string logStreamName, bool createStreamIfNotExists, CancellationToken stopToken)
{
var request = new DescribeLogStreamsRequest
{
LogGroupName = logGroup,
LogStreamNamePrefix = logStreamName
};
try
{
var describeLogsStreamsResponse = await _cloudWatchLogsClient.DescribeLogStreamsAsync(request, stopToken);
var logStream = describeLogsStreamsResponse.LogStreams
.FirstOrDefault(s => s.LogStreamName.Equals(logStreamName, StringComparison.CurrentCultureIgnoreCase));
if (logStream == null)
{
if (createStreamIfNotExists)
{
await CreateLogStreamAsync(logGroup, logStreamName, stopToken);
}
}
else
{
_sequenceToken = logStream.UploadSequenceToken;
}
_throttle.SetSuccess();
}
catch (ResourceNotFoundException rex)
{
// Create the log group if it doesn't exist.
if (rex.Message.Contains("log group does not exist", StringComparison.OrdinalIgnoreCase))
{
_logger?.LogInformation("Log group {0} does not exist. Creating it.", logGroup);
await CreateLogGroupAsync(logGroup, stopToken);
if (createStreamIfNotExists)
{
await CreateLogStreamAsync(logGroup, logStreamName, stopToken);
}
return;
}
}
}
/// <summary>
/// Creates the log stream if needed.
/// </summary>
/// <exception cref="Serilog.Sinks.AwsCloudWatch.AwsCloudWatchSinkException"></exception>
private async Task CreateLogStreamAsync()
{
// see if the log stream already exists
DescribeLogStreamsRequest describeLogStreamsRequest = new DescribeLogStreamsRequest {
LogGroupName = options.LogGroupName, LogStreamNamePrefix = logStreamName, Limit = 1
};
var describeLogStreamsResponse = await cloudWatchClient.DescribeLogStreamsAsync(describeLogStreamsRequest);
var logStream = describeLogStreamsResponse.LogStreams.FirstOrDefault(ls => string.Equals(ls.LogStreamName, logStreamName, StringComparison.OrdinalIgnoreCase));
// create log stream if it doesn't exist
if (logStream == null)
{
CreateLogStreamRequest createLogStreamRequest = new CreateLogStreamRequest
{
LogGroupName = options.LogGroupName,
LogStreamName = logStreamName
};
var createLogStreamResponse = await cloudWatchClient.CreateLogStreamAsync(createLogStreamRequest);
}
}
private async Task GetSequenceTokenAsync(string logStreamName)
{
var request = new DescribeLogStreamsRequest
{
LogGroupName = _logGroupName,
LogStreamNamePrefix = logStreamName
};
var describeLogsStreamsResponse = await _client.DescribeLogStreamsAsync(request);
LogStream logStream = describeLogsStreamsResponse.LogStreams
.FirstOrDefault(s => s.LogStreamName.Equals(logStreamName, StringComparison.CurrentCultureIgnoreCase));
if (logStream == null)
{
await CreateLogStreamAsync(logStreamName);
}
else
{
_sequenceToken = logStream.UploadSequenceToken;
}
}
public async Task DescribeLogStreamsTest__CancellationToken()
{
var request = new DescribeLogStreamsRequest();
var firstResponse = new DescribeLogStreamsResponse()
{
NextToken = "foo"
};
var secondResponse = new DescribeLogStreamsResponse()
{
NextToken = null
};
var paginator = _mockClient.Object.Paginators.DescribeLogStreams(request);
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
tokenSource.Cancel();
_mockClient.SetupSequence(x => x.DescribeLogStreamsAsync(It.IsAny <DescribeLogStreamsRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(firstResponse)
.ReturnsAsync(secondResponse);
await Assert.ThrowsAsync <OperationCanceledException>(async() => await LoopOverLogStreams(paginator, token));
}
static void Main(string[] args)
{
var logClient = new AmazonCloudWatchLogsClient();
// Add a new log group for testing
const string newLogGroupName = "NewLogGroup";
DescribeLogGroupsResponse dlgr = logClient.DescribeLogGroups();
var groups = new List <LogGroup> {
};
groups = dlgr.LogGroups;
LogGroup lg = new LogGroup();
lg.LogGroupName = newLogGroupName;
// Look for our new log group name to determine if we need to do setup
LogGroup result = groups.Find(
delegate(LogGroup bk)
{
return(bk.LogGroupName == newLogGroupName);
}
);
if (result != null)
{
Console.WriteLine(result.LogGroupName + " found");
}
else
{
//Haven't seen this log group, set it up
CreateLogGroupRequest clgr = new CreateLogGroupRequest(newLogGroupName);
logClient.CreateLogGroup(clgr);
// Create a file to sace next SequenceToken in
File.CreateText("..\\..\\" + lg.LogGroupName + ".txt");
CreateLogStreamRequest csr = new CreateLogStreamRequest(lg.LogGroupName, newLogGroupName);
logClient.CreateLogStream(csr);
}
string tokenFile = "";
try
{
Console.WriteLine(lg.LogGroupName);
//Pick up the next sequence token from the last run
tokenFile = lg.LogGroupName;
StreamReader sr = File.OpenText("..\\..\\" + tokenFile + ".txt");
string sequenceToken = sr.ReadLine();
sr.Close();
lg.RetentionInDays = 30;
string groupName = lg.LogGroupName;;
TestMetricFilterRequest tmfr = new TestMetricFilterRequest();
List <InputLogEvent> logEvents = new List <InputLogEvent>(3);
InputLogEvent ile = new InputLogEvent();
ile.Message = "Test Event 1";
//DateTime dt = new DateTime(1394793518000);
DateTime dt = new DateTime(2017, 01, 11);
ile.Timestamp = dt;
logEvents.Add(ile);
ile.Message = "Test Event 2";
logEvents.Add(ile);
ile.Message = "This message also contains an Error";
logEvents.Add(ile);
DescribeLogStreamsRequest dlsr = new DescribeLogStreamsRequest(groupName);
PutLogEventsRequest pler = new PutLogEventsRequest(groupName, tokenFile, logEvents);
pler.SequenceToken = sequenceToken; //use last sequence token
PutLogEventsResponse plerp = new PutLogEventsResponse();
plerp = logClient.PutLogEvents(pler);
Console.WriteLine("Next sequence token = " + plerp.NextSequenceToken);
FileStream fs = File.OpenWrite("..\\..\\" + tokenFile + ".txt");
fs.Position = 0;
UTF8Encoding utf8 = new UTF8Encoding();
Byte[] encodedBytes = utf8.GetBytes(plerp.NextSequenceToken);
fs.Write(encodedBytes, 0, utf8.GetByteCount(plerp.NextSequenceToken));
fs.Close();
List <string> lem = new List <string>(1);
lem.Add("Error");
tmfr.LogEventMessages = lem;
tmfr.FilterPattern = "Error";
TestMetricFilterResponse tmfrp = new TestMetricFilterResponse();
tmfrp = logClient.TestMetricFilter(tmfr);
var results = new List <MetricFilterMatchRecord> {
};
results = tmfrp.Matches;
Console.WriteLine("Found " + results.Count.ToString() + " match records");
IEnumerator ie = results.GetEnumerator();
while (ie.MoveNext())
{
MetricFilterMatchRecord mfmr = (MetricFilterMatchRecord)ie.Current;
Console.WriteLine("Event Message = " + mfmr.EventMessage);
}
Console.WriteLine("Metric filter test done");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Get all the LogStream from the chosen LogGroup
/// </summary>
/// <param name="awsLogGroupName"></param>
/// <returns>return all LogStreams from the chosen LogGroup</returns>
public DescribeLogStreamsResponse GetLogStreams(string awsLogGroupName)
{
awsLogStream = new DescribeLogStreamsRequest();
awsLogStream.LogGroupName = awsLogGroupName;
return(awsCloudwatchClient.DescribeLogStreams(awsLogStream));
}
internal void ForwardLogs()
{
do
{
Action pushLogsToCloudWatchAction = () =>
{
LogMessageDTO logMessageObj;
while (LogService.taskQueue.TryDequeue(out logMessageObj))
{
try
{
using (IAmazonCloudWatchLogs logsclient = Amazon.AWSClientFactory.CreateAmazonCloudWatchLogsClient(this.cloudWatchAccessKey, this.cloudWatchSecretKey, this.cloudWatchRegion))
{
string logStreamName = string.IsNullOrWhiteSpace(logMessageObj.ApplicationAlias) ? "Custom" : logMessageObj.ApplicationAlias;
// put the object into JSON format and send it to CloudWatch
List <InputLogEvent> logEvents = new List <InputLogEvent>();
InputLogEvent logEntry = new InputLogEvent();
logEntry.Message = JsonConvert.SerializeObject(logMessageObj);
logEntry.Timestamp = logMessageObj.Timestamp;
logEvents.Add(logEntry);
PutLogEventsRequest request = new PutLogEventsRequest(this.logGroupName, logStreamName, logEvents);
PutLogEventsResponse response = null;
for (int i = 0; i < 5; ++i)
{
try
{
lock (this.criticalSection)
{
// if we have a token, set it
if (LogStreamTokenMap.ContainsKey(logStreamName))
{
request.SequenceToken = LogStreamTokenMap[logStreamName];
}
// put the logs and get the token for the next submissions of logs
response = logsclient.PutLogEvents(request);
var newToken = response.NextSequenceToken;
if (LogStreamTokenMap.ContainsKey(logStreamName))
{
LogStreamTokenMap[logStreamName] = newToken;
}
else
{
LogStreamTokenMap.Add(logStreamName, newToken);
}
}
// if we successfully pushed the logs, exit the loop, otherwise we will exit in 5 tries
break;
}
catch (InvalidSequenceTokenException)
{
// we don't have the right token for the next sequence in the stream, so get it again
// in fact we will refresh all tokens for all streams
var logstreamsrequest = new DescribeLogStreamsRequest(this.logGroupName);
var logStreamResponse = logsclient.DescribeLogStreams(logstreamsrequest);
var logstreamsList = logStreamResponse.LogStreams;
lock (this.criticalSection)
{
foreach (var logstream in logstreamsList)
{
var appname = logstream.LogStreamName;
var token = logstream.UploadSequenceToken;
if (LogStreamTokenMap.ContainsKey(appname))
{
LogStreamTokenMap[appname] = token;
}
else
{
LogStreamTokenMap.Add(appname, token);
}
}
}
}
catch (ResourceNotFoundException)
{
// we likely introduced a new log stream that needs to be provisioned in CloudWatch
// ignore exceptions in creation
try
{
CreateLogGroupRequest logGroup = new CreateLogGroupRequest(this.logGroupName);
logsclient.CreateLogGroup(logGroup);
}
catch (Exception)
{ }
try
{
CreateLogStreamRequest logStream = new CreateLogStreamRequest(this.logGroupName, logStreamName);
logsclient.CreateLogStream(logStream);
lock (this.criticalSection)
{
LogStreamTokenMap.Remove(logStreamName);
}
}
catch (Exception)
{ }
}
}
if (response.HttpStatusCode == HttpStatusCode.OK)
{
++LogService.successfulForwards;
}
else
{
++LogService.failedForwards;
}
}
}
catch (Exception)
{
// can't really log this exception to avoid cyclical logging and deadlocks
++LogService.numExceptions;
}
}
};
// Start 5 parallel tasks to consume the logs from the queue
// the problem here is that the logs might not be pushed in order to CloudWatch
// However, that's ok since there might be multiple instances of this service and logs could be coming
// in to all instances at the same time and we might push logs to CloudWatch out of order
Parallel.Invoke(pushLogsToCloudWatchAction, pushLogsToCloudWatchAction, pushLogsToCloudWatchAction, pushLogsToCloudWatchAction, pushLogsToCloudWatchAction);
// sleep before getting into another iteration of this loop to look for logs
Thread.Sleep(1000);
} while (true);
}
void Writer(object sender, ElapsedEventArgs e)
{
var logEvents = new List <InputLogEvent>();
try
{
var more = true;
while (more)
{
InputLogEvent item;
more = items.TryTake(out item);
if (more)
{
logEvents.Add(item);
}
}
if (logEvents.Count == 0)
{
return;
}
if (!Settings.Default.SendUsageData)
{
return;
}
using (var logs = new AmazonCloudWatchLogsClient(AwsKeys.AccessKey, AwsKeys.SecretKey, RegionEndpoint.APSoutheast2))
{
var request = new PutLogEventsRequest(AwsKeys.GroupName, LogStreamName, logEvents);
var describeLogStreamsRequest = new DescribeLogStreamsRequest(AwsKeys.GroupName)
{
LogStreamNamePrefix = trackingId,
Descending = true
};
var describeLogStreamsResponse = logs.DescribeLogStreams(describeLogStreamsRequest);
var logStreams = describeLogStreamsResponse.LogStreams;
var logStream = logStreams.FirstOrDefault(ls => ls.LogStreamName == LogStreamName);
if (logStream != null)
{
var token = logStream.UploadSequenceToken;
request.SequenceToken = token;
checkResponse(logs.PutLogEvents(request));
}
else
{
var createRequest = new CreateLogStreamRequest(AwsKeys.GroupName, LogStreamName);
checkResponse(logs.CreateLogStream(createRequest));
checkResponse(logs.PutLogEvents(request));
}
}
}
catch (Exception ee)
{
AttempToRestoreErrors(logEvents, ee);
}
finally
{
if (timer != null)
{
timer.Start();
}
}
}
/// <summary>
///
/// <para>WriteLogs:</para>
///
/// <para>Writes logs to the logging service</para>
///
/// <para>Check <seealso cref="IBLoggingServiceInterface.WriteLogs"/> for detailed documentation</para>
///
/// </summary>
public bool WriteLogs(
List <BLoggingParametersStruct> _Messages,
string _LogGroupName,
string _LogStreamName,
bool _bAsync = true,
Action <string> _ErrorMessageAction = null)
{
if (_Messages == null || _Messages.Count == 0)
{
return(false);
}
if (_bAsync)
{
BTaskWrapper.Run(() =>
{
WriteLogs(_Messages, _LogGroupName, _LogStreamName, false, _ErrorMessageAction);
});
return(true);
}
else
{
_LogGroupName = BUtility.EncodeStringForTagging(_LogGroupName);
_LogStreamName = BUtility.EncodeStringForTagging(_LogStreamName);
string SequenceToken = null;
bool bLogStreamAndGroupExists = false;
try
{
var DescribeStreamRequest = new DescribeLogStreamsRequest(_LogGroupName);
using (var CreatedDescribeTask = CloudWatchLogsClient.DescribeLogStreamsAsync(DescribeStreamRequest))
{
CreatedDescribeTask.Wait();
if (CreatedDescribeTask.Result != null && CreatedDescribeTask.Result.LogStreams != null && CreatedDescribeTask.Result.LogStreams.Count > 0)
{
foreach (var Current in CreatedDescribeTask.Result.LogStreams)
{
if (Current != null && Current.LogStreamName == _LogStreamName)
{
SequenceToken = Current.UploadSequenceToken;
bLogStreamAndGroupExists = true;
break;
}
}
}
}
}
catch (Exception)
{
bLogStreamAndGroupExists = false;
}
if (!bLogStreamAndGroupExists)
{
try
{
var CreateGroupRequest = new CreateLogGroupRequest(_LogGroupName);
using (var CreatedGroupTask = CloudWatchLogsClient.CreateLogGroupAsync(CreateGroupRequest))
{
CreatedGroupTask.Wait();
}
}
catch (Exception e)
{
if (!(e is ResourceAlreadyExistsException))
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
try
{
var CreateStreamRequest = new CreateLogStreamRequest(_LogGroupName, _LogStreamName);
using (var CreatedStreamTask = CloudWatchLogsClient.CreateLogStreamAsync(CreateStreamRequest))
{
CreatedStreamTask.Wait();
}
}
catch (Exception e)
{
if (!(e is ResourceAlreadyExistsException))
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
}
var LogEvents = new List <InputLogEvent>();
foreach (var Message in _Messages)
{
var LogEvent = new InputLogEvent()
{
Message = Message.Message,
Timestamp = DateTime.UtcNow
};
switch (Message.LogType)
{
case EBLoggingServiceLogType.Debug:
LogEvent.Message = "Debug-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Info:
LogEvent.Message = "Info-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Warning:
LogEvent.Message = "Warning-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Error:
LogEvent.Message = "Error-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Critical:
LogEvent.Message = "Critical-> " + LogEvent.Message;
break;
}
LogEvents.Add(LogEvent);
}
try
{
var PutRequest = new PutLogEventsRequest(_LogGroupName, _LogStreamName, LogEvents)
{
SequenceToken = SequenceToken
};
using (var CreatedPutTask = CloudWatchLogsClient.PutLogEventsAsync(PutRequest))
{
CreatedPutTask.Wait();
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
return(true);
}
}
