void CwLog(string group_name, string stream_name, string body)
{
using (var cwl = new AmazonCloudWatchLogsClient(aws_credentials, aws_region))
{
int attempts = 0;
do
{
try
{
attempts++;
var request = new PutLogEventsRequest(group_name, stream_name, new List <InputLogEvent> {
new InputLogEvent
{
Timestamp = DateTime.Now,
Message = body
}
});
request.SequenceToken = cw_logstream_sequence_token;
var ret = cwl.PutLogEvents(request);
// Update sequence token for next put
cw_logstream_sequence_token = ret.NextSequenceToken;
break; // success
}
catch (Amazon.CloudWatchLogs.Model.ResourceNotFoundException e)
{
Console.WriteLine($"type: {e.ErrorType} code: {e.ErrorCode} source: {e.Source} ");
Console.WriteLine(e.Data);
CreateCwLogGroup(cw_log_group_name);
CreateCwLogSream(cw_log_stream_name);
// Log group doesn't exist. Let's create. This only needs to be done once
Task.Delay(1000);
}
catch (Amazon.CloudWatchLogs.Model.InvalidSequenceTokenException e)
{
// Each log event must contain a sequence value, unless it's the first event
// https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudWatchLogs/TPutLogEventsRequest.html
cw_logstream_sequence_token = e.ExpectedSequenceToken;
// Now that we have the sequence token, try one more time.
Console.WriteLine("Exception caught for unexpected squence token. It's now updated and will retry.");
Task.Delay(1000);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.WriteLine("This exception is not handled, will not retry :-( ");
break;
}
if (attempts > 2)
{
Console.WriteLine("Unable to send log event retries exhausted.");
break;
}
} while (true);
}
}
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);
}
}
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>
/// This method will upload the event queue to CloudWatch Logs
/// </summary>
private void Publish()
{
base.Flush();
//If we were unable to connect then bail out
if (_ConnectionFailed)
{
return;
}
//Typically Publish will be called by the PublisherThread, but it can be called explicitly
//with a Flush. If two threads publish at the same time the Token will get out of sync.
//Therefore let's lock this section to be sure we only publish one batch at a time.
lock (_EventQueue)
{
//If this is the first time we published, we need to connect to get the token.
if (!_Connected)
{
Connect();
}
//If we are not connected then do nothing. This is just debugging information
if (_Connected)
{
//We are going to publish in batches upto the max message size until the queue is empty
while (_EventQueue.Count > 0)
{
//Buffer for a batch of messages
List <InputLogEvent> publishBuffer = new List <InputLogEvent>();
int buffersize = 0;
//Read events from the queue and put them in the buffer
//We will either read the entire queue or exceed the max message size
InputLogEvent logEvent;
while (_EventQueue.TryDequeue(out logEvent))
{
//Keep track of the buffer size
buffersize += logEvent.Message.Length;
//Add the event to the buffer
publishBuffer.Add(logEvent);
//If the buffer gets too big, stop and publish
if (buffersize > MAX_BUFFER_SIZE)
{
break;
}
}
//If there are any messages in the buffer, publish it
if (publishBuffer.Count > 0)
{
try
{
var response = _Client.PutLogEvents(new PutLogEventsRequest()
{
LogGroupName = GroupName,
LogStreamName = StreamName,
SequenceToken = _Token,
LogEvents = publishBuffer
}
);
//Update the token needed for the next publish
_Token = response.NextSequenceToken;
}
catch
{
if (FailOnError)
{
throw;
}
}
}
}
}
}
}
