public object ReadJson(ref JReader reader)
{
var valid = true;
var flags = new Dictionary <string, FlagState>();
for (var topLevelObj = reader.Object(); topLevelObj.Next(ref reader);)
{
var key = topLevelObj.Name.ToString();
switch (key)
{
case "$valid":
valid = reader.Bool();
break;
case "$flagsState":
for (var flagsObj = reader.Object(); flagsObj.Next(ref reader);)
{
var subKey = flagsObj.Name.ToString();
var flag = flags.ContainsKey(subKey) ? flags[subKey] : new FlagState();
for (var metaObj = reader.Object(); metaObj.Next(ref reader);)
{
switch (metaObj.Name.ToString())
{
case "variation":
flag.Variation = reader.IntOrNull();
break;
case "version":
flag.Version = reader.IntOrNull();
break;
case "trackEvents":
flag.TrackEvents = reader.Bool();
break;
case "debugEventsUntilDate":
var n = reader.LongOrNull();
flag.DebugEventsUntilDate = n.HasValue ? UnixMillisecondTime.OfMillis(n.Value) :
(UnixMillisecondTime?)null;
break;
case "reason":
flag.Reason = EvaluationReasonConverter.ReadJsonNullableValue(ref reader);
break;
}
}
flags[subKey] = flag;
}
break;
default:
var flagForValue = flags.ContainsKey(key) ? flags[key] : new FlagState();
flagForValue.Value = LdValueConverter.ReadJsonValue(ref reader);
flags[key] = flagForValue;
break;
}
}
return(new FeatureFlagsState(valid, flags));
}
internal static ImmutableList <LdValue> ReadValues(ref JReader r)
{
var builder = ImmutableList.CreateBuilder <LdValue>();
for (var arr = r.ArrayOrNull(); arr.Next(ref r);)
{
builder.Add(LdValueConverter.ReadJsonValue(ref r));
}
return(builder.ToImmutable());
}
internal static void WriteValues(IValueWriter writer, IEnumerable <LdValue> values)
{
var arr = writer.Array();
foreach (var v in values)
{
LdValueConverter.WriteJsonValue(v, arr);
}
arr.End();
}
public void WriteOutputEvent(object e)
{
_obj = _jsonWriter.Object();
switch (e)
{
case EvaluationEvent ee:
WriteEvaluationEvent(ee, false);
break;
case IdentifyEvent ie:
WriteBase("identify", ie.Timestamp, ie.User?.Key);
WriteUser(ie.User);
break;
case CustomEvent ce:
WriteBase("custom", ce.Timestamp, ce.EventKey);
WriteUserOrKey(ce.User, false, true);
if (!ce.Data.IsNull)
{
LdValueConverter.WriteJsonValue(ce.Data, _obj.Name("data"));
}
if (ce.MetricValue.HasValue)
{
_obj.Name("metricValue").Double(ce.MetricValue.Value);
}
break;
case AliasEvent ae:
WriteBase("alias", ae.Timestamp, ae.Key);
_obj.Name("contextKind").String(ae.ContextKind.ToIdentifier());
_obj.Name("previousKey").String(ae.PreviousKey);
_obj.Name("previousContextKind").String(ae.PreviousContextKind.ToIdentifier());
break;
case EventProcessorInternal.IndexEvent ie:
WriteBase("index", ie.Timestamp, null);
WriteUserOrKey(ie.User, true, false);
break;
case EventProcessorInternal.DebugEvent de:
WriteEvaluationEvent(de.FromEvent, true);
break;
default:
break;
}
_obj.End();
}
private static FullDataSet <ItemDescriptor> ParseJson(ref JReader r, int version)
{
var flagsBuilder = ImmutableList.CreateBuilder <KeyValuePair <string, ItemDescriptor> >();
var segmentsBuilder = ImmutableList.CreateBuilder <KeyValuePair <string, ItemDescriptor> >();
for (var obj = r.Object(); obj.Next(ref r);)
{
switch (obj.Name.ToString())
{
case "flags":
for (var subObj = r.ObjectOrNull(); subObj.Next(ref r);)
{
var key = subObj.Name.ToString();
var flag = FeatureFlagSerialization.Instance.ReadJson(ref r) as FeatureFlag;
flagsBuilder.Add(new KeyValuePair <string, ItemDescriptor>(key, new ItemDescriptor(version,
FlagWithVersion(flag, version))));
}
break;
case "flagValues":
for (var subObj = r.ObjectOrNull(); subObj.Next(ref r);)
{
var key = subObj.Name.ToString();
var value = LdValueConverter.ReadJsonValue(ref r);
var flag = FlagWithValue(key, value, version);
flagsBuilder.Add(new KeyValuePair <string, ItemDescriptor>(key, new ItemDescriptor(version, flag)));
}
break;
case "segments":
for (var subObj = r.ObjectOrNull(); subObj.Next(ref r);)
{
var key = subObj.Name.ToString();
var segment = SegmentSerialization.Instance.ReadJson(ref r) as Segment;
segmentsBuilder.Add(new KeyValuePair <string, ItemDescriptor>(key, new ItemDescriptor(version,
SegmentWithVersion(segment, version))));
}
break;
}
}
return(new FullDataSet <ItemDescriptor>(ImmutableList.Create <KeyValuePair <DataKind, KeyedItems <ItemDescriptor> > >(
new KeyValuePair <DataKind, KeyedItems <ItemDescriptor> >(DataModel.Features,
new KeyedItems <ItemDescriptor>(flagsBuilder.ToImmutable())),
new KeyValuePair <DataKind, KeyedItems <ItemDescriptor> >(DataModel.Segments,
new KeyedItems <ItemDescriptor>(segmentsBuilder.ToImmutable()))
)));
}
public void WriteJson(object value, IValueWriter writer)
{
var user = (User)value;
if (user is null)
{
writer.Null();
return;
}
var obj = writer.Object();
obj.Name("key").String(user.Key);
obj.MaybeName("secondary", user.Secondary != null).String(user.Secondary);
obj.MaybeName("ip", user.IPAddress != null).String(user.IPAddress);
obj.MaybeName("country", user.Country != null).String(user.Country);
obj.MaybeName("firstName", user.FirstName != null).String(user.FirstName);
obj.MaybeName("lastName", user.LastName != null).String(user.LastName);
obj.MaybeName("name", user.Name != null).String(user.Name);
obj.MaybeName("avatar", user.Avatar != null).String(user.Avatar);
obj.MaybeName("email", user.Email != null).String(user.Email);
if (user.AnonymousOptional.HasValue)
{
obj.Name("anonymous").Bool(user.Anonymous);
}
if (user.Custom.Count > 0)
{
var customObj = obj.Name("custom").Object();
foreach (var kv in user.Custom)
{
LdValueConverter.WriteJsonValue(kv.Value, customObj.Name(kv.Key));
}
customObj.End();
}
if (user.PrivateAttributeNames.Count > 0)
{
var attrsArr = obj.Name("privateAttributeNames").Array();
foreach (var n in user.PrivateAttributeNames)
{
attrsArr.String(n);
}
attrsArr.End();
}
obj.End();
}
private void WriteUser(User user)
{
if (user is null)
{
return;
}
var eu = EventUser.FromUser(user, _config);
var userObj = _obj.Name("user").Object();
userObj.Name("key").String(eu.Key);
userObj.MaybeName("secondary", eu.Secondary != null).String(eu.Secondary);
userObj.MaybeName("ip", eu.IPAddress != null).String(eu.IPAddress);
userObj.MaybeName("country", eu.Country != null).String(eu.Country);
userObj.MaybeName("firstName", eu.FirstName != null).String(eu.FirstName);
userObj.MaybeName("lastName", eu.LastName != null).String(eu.LastName);
userObj.MaybeName("name", eu.Name != null).String(eu.Name);
userObj.MaybeName("avatar", eu.Avatar != null).String(eu.Avatar);
userObj.MaybeName("email", eu.Email != null).String(eu.Email);
if (eu.Anonymous.HasValue)
{
userObj.Name("anonymous").Bool(eu.Anonymous.Value);
}
if (eu.Custom != null && eu.Custom.Count > 0)
{
var customObj = userObj.Name("custom").Object();
foreach (var kv in eu.Custom)
{
LdValueConverter.WriteJsonValue(kv.Value, customObj.Name(kv.Key));
}
customObj.End();
}
if (eu.PrivateAttrs != null)
{
var arr = userObj.Name("privateAttrs").Array();
foreach (var a in eu.PrivateAttrs)
{
arr.String(a);
}
arr.End();
}
userObj.End();
}
private void WriteEvaluationEvent(EvaluationEvent ee, bool debug)
{
WriteBase(debug ? "debug" : "feature", ee.Timestamp, ee.FlagKey);
WriteUserOrKey(ee.User, debug, true);
if (ee.FlagVersion.HasValue)
{
_obj.Name("version").Int(ee.FlagVersion.Value);
}
if (ee.Variation.HasValue)
{
_obj.Name("variation").Int(ee.Variation.Value);
}
LdValueConverter.WriteJsonValue(ee.Value, _obj.Name("value"));
if (!ee.Default.IsNull)
{
LdValueConverter.WriteJsonValue(ee.Default, _obj.Name("default"));
}
_obj.MaybeName("prereqOf", ee.PrereqOf != null).String(ee.PrereqOf);
WriteReason(ee.Reason);
}
public void WriteJson(object value, IValueWriter writer)
{
var state = value as FeatureFlagsState;
if (state is null)
{
writer.Null();
return;
}
var obj = writer.Object();
foreach (var entry in state._flags)
{
LdValueConverter.WriteJsonValue(entry.Value.Value, obj.Name(entry.Key));
}
obj.Name("$valid").Bool(state._valid);
var allMetadataObj = obj.Name("$flagsState").Object();
foreach (var entry in state._flags)
{
var flagMetadataObj = allMetadataObj.Name(entry.Key).Object();
var meta = entry.Value;
flagMetadataObj.Name("variation").IntOrNull(meta.Variation);
flagMetadataObj.Name("version").IntOrNull(meta.Version);
flagMetadataObj.MaybeName("trackEvents", meta.TrackEvents).Bool(meta.TrackEvents);
flagMetadataObj.MaybeName("debugEventsUntilDate", meta.DebugEventsUntilDate.HasValue)
.Long(meta.DebugEventsUntilDate?.Value ?? 0);
if (meta.Reason.HasValue)
{
EvaluationReasonConverter.WriteJsonValue(meta.Reason.Value, flagMetadataObj.Name("reason"));
}
flagMetadataObj.End();
}
allMetadataObj.End();
obj.End();
}
private static FlagFileData ParseJson(ref JReader r)
{
var ret = new FlagFileData
{
Flags = new Dictionary <string, FeatureFlag>(),
FlagValues = new Dictionary <string, LdValue>(),
Segments = new Dictionary <string, Segment>()
};
for (var obj = r.Object(); obj.Next(ref r);)
{
switch (obj.Name.ToString())
{
case "flags":
for (var subObj = r.ObjectOrNull(); subObj.Next(ref r);)
{
ret.Flags[subObj.Name.ToString()] = FeatureFlagSerialization.Instance.ReadJson(ref r) as FeatureFlag;
}
break;
case "flagValues":
for (var subObj = r.ObjectOrNull(); subObj.Next(ref r);)
{
ret.FlagValues[subObj.Name.ToString()] = LdValueConverter.ReadJsonValue(ref r);
}
break;
case "segments":
for (var subObj = r.ObjectOrNull(); subObj.Next(ref r);)
{
ret.Segments[subObj.Name.ToString()] = SegmentSerialization.Instance.ReadJson(ref r) as Segment;
}
break;
}
}
return(ret);
}
public void WriteSummaryEvent(EventSummary summary)
{
var obj = _jsonWriter.Object();
obj.Name("kind").String("summary");
obj.Name("startDate").Long(summary.StartDate.Value);
obj.Name("endDate").Long(summary.EndDate.Value);
var flagsObj = obj.Name("features").Object();
var unprocessedCounters = summary.Counters.Select(kv => MutableKeyValuePair <EventsCounterKey, EventsCounterValue> .FromKeyValue(kv)).ToArray();
for (var i = 0; i < unprocessedCounters.Length; i++)
{
var firstEntry = unprocessedCounters[i];
if (firstEntry.Value is null)
{ // already processed
continue;
}
var flagKey = firstEntry.Key.Key;
var flagDefault = firstEntry.Value.Default;
var flagObj = flagsObj.Name(flagKey).Object();
LdValueConverter.WriteJsonValue(flagDefault, flagObj.Name("default"));
var countersArr = flagObj.Name("counters").Array();
for (var j = i; j < unprocessedCounters.Length; j++)
{
var entry = unprocessedCounters[j];
var key = entry.Key;
if (key.Key == flagKey && entry.Value != null)
{
var counter = entry.Value;
unprocessedCounters[j].Value = null; // mark as already processed
var counterObj = countersArr.Object();
if (key.Variation.HasValue)
{
counterObj.Name("variation").Int(key.Variation.Value);
}
LdValueConverter.WriteJsonValue(counter.FlagValue, counterObj.Name("value"));
if (key.Version.HasValue)
{
counterObj.Name("version").Int(key.Version.Value);
}
else
{
counterObj.Name("unknown").Bool(true);
}
counterObj.Name("count").Int(counter.Count);
counterObj.End();
}
}
countersArr.End();
flagObj.End();
}
flagsObj.End();
obj.End();
}
public object ReadJson(ref JReader reader)
{
var obj = reader.ObjectOrNull().WithRequiredProperties(_requiredProperties);
if (!obj.IsDefined)
{
return(null);
}
var builder = User.Builder("");
try
{
while (obj.Next(ref reader))
{
switch (obj.Name.ToString())
{
case "key":
builder.Key(reader.String());
break;
case "secondary":
builder.Secondary(reader.StringOrNull());
break;
case "ip":
builder.IPAddress(reader.StringOrNull());
break;
case "country":
builder.Country(reader.StringOrNull());
break;
case "firstName":
builder.FirstName(reader.StringOrNull());
break;
case "lastName":
builder.LastName(reader.StringOrNull());
break;
case "name":
builder.Name(reader.StringOrNull());
break;
case "avatar":
builder.Avatar(reader.StringOrNull());
break;
case "email":
builder.Email(reader.StringOrNull());
break;
case "anonymous":
builder.AnonymousOptional(reader.BoolOrNull());
break;
case "custom":
for (var customObj = reader.ObjectOrNull(); customObj.Next(ref reader);)
{
builder.Custom(customObj.Name.ToString(),
LdValueConverter.ReadJsonValue(ref reader));
}
break;
case "privateAttributeNames":
var internalBuilder = builder as UserBuilder;
for (var arr = reader.ArrayOrNull(); arr.Next(ref reader);)
{
internalBuilder.AddPrivateAttribute(reader.String());
}
break;
}
}
}
catch (Exception e)
{
throw reader.TranslateException(e);
}
return(builder.Build());
}
