internal GetLogEventsResponse GetLogEvents(GetLogEventsRequest request)
{
var marshaller = new GetLogEventsRequestMarshaller();
var unmarshaller = GetLogEventsResponseUnmarshaller.Instance;
return(Invoke <GetLogEventsRequest, GetLogEventsResponse>(request, marshaller, unmarshaller));
}
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 async ValueTask <GetLogEventsResponse> GetEventsAsync(GetLogEventsRequest request)
{
return(new GetLogEventsResponse()
{
Events = new List <LogEventModel>()
});
}
private async Task <IEnumerable <string> > GetLogMessages(string logGroup, string logStreamName)
{
var request = new GetLogEventsRequest
{
LogGroupName = logGroup,
LogStreamName = logStreamName
};
;
var logMessages = new List <string>();
var listStacksPaginator = _client.Paginators.GetLogEvents(request);
await foreach (var response in listStacksPaginator.Responses)
{
// When there are no new events, Events list is returned empty.
// Therefore, we want to stop the paginator and return the response.
// Otherwise, paginator will end up in an infinite loop.
if (response.Events.Count == 0)
{
break;
}
var messages = response.Events.Select(e => e.Message);
logMessages.AddRange(messages);
}
return(logMessages);
}
/// <summary>
/// Initiates the asynchronous execution of the GetLogEvents operation.
/// <seealso cref="Amazon.CloudWatchLogs.IAmazonCloudWatchLogs"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetLogEvents 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 <GetLogEventsResponse> GetLogEventsAsync(GetLogEventsRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetLogEventsRequestMarshaller();
var unmarshaller = GetLogEventsResponseUnmarshaller.Instance;
return(Invoke <IRequest, GetLogEventsRequest, GetLogEventsResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
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);
}
internal GetLogEventsResponse GetLogEvents(GetLogEventsRequest request)
{
var task = GetLogEventsAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
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));
}
/// <summary>
/// Get and write logs to chosen file, This is not at right way to do it, but every task, thread, async/await either lock the GUI or is not working.
/// </summary>
/// <param name="awsLogGroupName"></param>
/// <param name="awsLogStreamName"></param>
/// <param name="fromdays"></param>
/// <param name="todays"></param>
public List <GetLogEventsResponse> GetLogsFrom(string awsLogGroupName, DescribeLogStreamsResponse awsLogStreamName, double fromdays, double todays)
{
List <GetLogEventsResponse> Logs = new List <GetLogEventsResponse>();
foreach (var item in awsLogStreamName.LogStreams)
{
awsGetLogsEvent = new GetLogEventsRequest();
awsGetLogsEvent.LogGroupName = awsLogGroupName;
awsGetLogsEvent.LogStreamName = item.LogStreamName;
awsGetLogsEvent.StartTime = DateTime.Today.AddDays(fromdays);
awsGetLogsEvent.EndTime = DateTime.Today.AddDays(todays + 1);
Logs.Add(awsCloudwatchClient.GetLogEvents(awsGetLogsEvent));
}
return(Logs);
}
static GetLogEventsRequest mkreq(string tok = null)
{
var r = new GetLogEventsRequest {
LogStreamName = Environment.GetEnvironmentVariable("FURL_LOG_STREAM"),
LogGroupName = Environment.GetEnvironmentVariable("FURL_LOG_GROUP"),
Limit = 5000
};
if (tok != null)
{
r.NextToken = tok;
}
else
{
r.StartFromHead = true;
}
return(r);
}
public async Task <string> GetCloudWatchLogEventsAsync()
{
var events = new StringBuilder();
var request = new GetLogEventsRequest()
{
LogGroupName = LogGroupName,
LogStreamName = LogStreamName,
Limit = LogRowLimit
};
var response = await Client.GetLogEventsAsync(request);
foreach (OutputLogEvent logEvent in response.Events)
{
events.AppendLine(logEvent.Timestamp + ": " + logEvent.Message);
}
return(events.ToString());
}
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));
}
