private void OnMessage(object sender, EventSource.MessageReceivedEventArgs e)
{
try
{
HandleMessage(e.EventName, e.Message.Data);
}
catch (JsonReadException ex)
{
_log.Error("LaunchDarkly service request failed or received invalid data: {0}",
LogValues.ExceptionSummary(ex));
var errorInfo = new DataSourceStatus.ErrorInfo
{
Kind = DataSourceStatus.ErrorKind.InvalidData,
Message = ex.Message,
Time = DateTime.Now
};
_updateSink.UpdateStatus(DataSourceState.Interrupted, errorInfo);
_eventSource.Restart(false);
}
catch (Exception ex)
{
LogHelpers.LogException(_log, "Unexpected error in stream processing", ex);
}
}
private void OnMessage(object sender, EventSource.MessageReceivedEventArgs e)
{
try
{
HandleMessage(e.EventName, e.Message.DataUtf8Bytes.Data);
// The way the PreferDataAsUtf8Bytes option works in EventSource is that if the
// stream really is using UTF-8 encoding, the event data is passed to us directly
// in Message.DataUtf8Bytes as a byte array and does not need to be converted to
// a string. If the stream is for some reason using a different encoding, then
// EventSource reads the data as a string (automatically converted by .NET from
// whatever the encoding was), and then calling Message.DataUtf8Bytes converts
// that to UTF-8 bytes.
}
catch (JsonReadException ex)
{
_log.Error("LaunchDarkly service request failed or received invalid data: {0}",
LogValues.ExceptionSummary(ex));
var errorInfo = new DataSourceStatus.ErrorInfo
{
Kind = DataSourceStatus.ErrorKind.InvalidData,
Message = ex.Message,
Time = DateTime.Now
};
_dataSourceUpdates.UpdateStatus(DataSourceState.Interrupted, errorInfo);
_es.Restart(false);
}
catch (StreamStoreException)
{
if (!_storeStatusMonitoringEnabled)
{
if (!_lastStoreUpdateFailed)
{
_log.Warn("Restarting stream to ensure that we have the latest data");
}
_es.Restart(false);
}
_lastStoreUpdateFailed = true;
}
catch (Exception ex)
{
LogHelpers.LogException(_log, "Unexpected error in stream processing", ex);
_es.Restart(false);
}
}
private async void OnMessage(object sender, EventSource.MessageReceivedEventArgs e)
{
try
{
await _streamProcessor.HandleMessage(this, e.EventName, e.Message.Data);
}
catch (JsonReaderException ex)
{
Log.DebugFormat("Failed to deserialize JSON in {0} message:\n{1}",
ex, e.EventName, e.Message.Data);
Log.ErrorFormat("Encountered an error reading feature data: {0}",
ex, Util.ExceptionMessage(ex));
Restart();
}
catch (Exception ex)
{
Log.ErrorFormat("Encountered an unexpected error: {0}",
ex, Util.ExceptionMessage(ex));
Restart();
}
}
private async void OnMessage(object sender, EventSource.MessageReceivedEventArgs e)
{
try
{
switch (e.EventName)
{
case PUT:
_featureStore.Init(JsonConvert.DeserializeObject <PutData>(e.Message.Data).Data.ToGenericDictionary());
if (Interlocked.CompareExchange(ref _initialized, INITIALIZED, UNINITIALIZED) == 0)
{
_initTask.SetResult(true);
Log.Info("Initialized LaunchDarkly Stream Processor.");
}
break;
case PATCH:
PatchData patchData = JsonConvert.DeserializeObject <PatchData>(e.Message.Data);
string patchKey;
if (GetKeyFromPath(patchData.Path, VersionedDataKind.Features, out patchKey))
{
FeatureFlag flag = patchData.Data.ToObject <FeatureFlag>();
_featureStore.Upsert(VersionedDataKind.Features, flag);
}
else if (GetKeyFromPath(patchData.Path, VersionedDataKind.Segments, out patchKey))
{
Segment segment = patchData.Data.ToObject <Segment>();
_featureStore.Upsert(VersionedDataKind.Segments, segment);
}
else
{
Log.WarnFormat("Received patch event with unknown path: {0}", patchData.Path);
}
break;
case DELETE:
DeleteData deleteData = JsonConvert.DeserializeObject <DeleteData>(e.Message.Data);
string deleteKey;
if (GetKeyFromPath(deleteData.Path, VersionedDataKind.Features, out deleteKey))
{
_featureStore.Delete(VersionedDataKind.Features, deleteKey, deleteData.Version);
}
else if (GetKeyFromPath(deleteData.Path, VersionedDataKind.Segments, out deleteKey))
{
_featureStore.Delete(VersionedDataKind.Segments, deleteKey, deleteData.Version);
}
else
{
Log.WarnFormat("Received delete event with unknown path: {0}", deleteData.Path);
}
break;
case INDIRECT_PATCH:
await UpdateTaskAsync(e.Message.Data);
break;
}
}
catch (JsonReaderException ex)
{
Log.DebugFormat("Failed to deserialize feature flag or segment {0}:\n{1}",
ex,
e.EventName,
e.Message.Data);
Log.ErrorFormat("Encountered an error reading feature flag or segment configuration: {0}",
ex, Util.ExceptionMessage(ex));
RestartEventSource();
}
catch (Exception ex)
{
Log.ErrorFormat("Encountered an unexpected error: {0}",
ex, Util.ExceptionMessage(ex));
RestartEventSource();
}
}
