public void ShouldRecordInstrumentationForIsEnabled([Values(true, false)] Boolean enabled)
{
var instrumenter = new MockInstrumenter();
var feature = new Feature("Name", new MemoryAdapter(), instrumenter);
if (enabled)
{
feature.Enable();
}
else
{
feature.Disable();
}
instrumenter.Events.Clear();
feature.IsEnabled();
var expectedPayload = new InstrumentationPayload {
FeatureName = "Name",
Operation = "enabled?",
Thing = null,
Result = enabled
};
if (enabled)
{
expectedPayload.GateName = feature.BooleanGate.Name;
}
var expectedEvent = new MockInstrumenter.Event {
Type = InstrumentationType.FeatureOperation,
Payload = expectedPayload,
};
Assert.That(instrumenter.Events, Has.Member(expectedEvent));
}
public void ShouldRecordGateInstrumentationForIsEnabledFor([Values(true,false)] Boolean enabled)
{
var instrumenter = new MockInstrumenter();
var feature = new Feature("Name", new MemoryAdapter(), instrumenter);
var flipperActor = MockActor("User:5");
if (enabled)
{
feature.EnableActor(flipperActor);
} else
{
feature.DisableActor(flipperActor);
}
instrumenter.Events.Clear();
feature.IsEnabledFor(flipperActor);
var expectedPayload = new InstrumentationPayload {
FeatureName = "Name",
GateName = "actor",
Operation = "open?",
Thing = flipperActor,
Result = enabled,
};
if (enabled)
{
expectedPayload.GateName = feature.ActorGate.Name;
}
var expectedEvent = new MockInstrumenter.Event {
Type = InstrumentationType.GateOperation,
Payload = expectedPayload,
};
Assert.That(instrumenter.Events, Has.Member(expectedEvent));
}
public void ShouldRecordInstrumentationForIsEnabled([Values(true,false)] Boolean enabled)
{
var instrumenter = new MockInstrumenter();
var feature = new Feature("Name", new MemoryAdapter(), instrumenter);
if (enabled)
{
feature.Enable();
} else
{
feature.Disable();
}
instrumenter.Events.Clear();
feature.IsEnabled();
var expectedPayload = new InstrumentationPayload {
FeatureName = "Name",
Operation = "enabled?",
Thing = null,
Result = enabled
};
var expectedEvent = new MockInstrumenter.Event {
Type = InstrumentationType.FeatureOperation,
Payload = expectedPayload,
};
Assert.That(instrumenter.Events, Has.Member(expectedEvent));
}
private bool IsEnabled(object thing)
{
var payload = new InstrumentationPayload {
FeatureName = Name,
Operation = "enabled?",
};
if (thing != null)
{
payload.Thing = thing;
}
using (Instrumenter.InstrumentFeature(payload))
{
var values = GateValues;
var openGate = Gates.FirstOrDefault(gate => InstrumentGate(gate, "open?", thing, x => x.IsOpen(thing, values[x.Key], Name)));
bool result;
if (openGate != null)
{
payload.GateName = openGate.Name;
result = true;
}
else
{
result = false;
}
payload.Result = result;
return(result);
}
}
public void Disable(Feature feature, FlipperDotNet.Gate.IGate gate, object thing)
{
var instrumentationPayload = new InstrumentationPayload {
Operation = "disable",
AdapterName = Adapter.Name,
FeatureName = feature.Name,
};
using (Instrumenter.InstrumentAdapter(instrumentationPayload))
{
Adapter.Disable(feature, gate, thing);
}
}
public void Clear(Feature feature)
{
var instrumentationPayload = new InstrumentationPayload {
Operation = "clear",
AdapterName = Adapter.Name,
FeatureName = feature.Name,
};
using (Instrumenter.InstrumentAdapter(instrumentationPayload))
{
Adapter.Clear(feature);
}
}
public void Clear(Feature feature)
{
var instrumentationPayload = new InstrumentationPayload {
Operation = "clear",
AdapterName = Adapter.Name,
FeatureName = feature.Name,
};
using (Instrumenter.InstrumentAdapter(instrumentationPayload))
{
Adapter.Clear(feature);
}
}
public void Remove(Feature feature)
{
var instrumentationPayload = new InstrumentationPayload {
Operation = "remove",
AdapterName = Adapter.Name,
FeatureName = feature.Name,
};
using (Instrumenter.InstrumentAdapter(instrumentationPayload))
{
Adapter.Remove(feature);
}
}
public void ShouldRecordInstrumentationWhenLoadingFeatures()
{
var feature = Flipper.Feature("Stats");
var result = Adapter.Features;
var expectedPayload = new InstrumentationPayload {
Operation = "features",
AdapterName = "memory",
Result = result,
};
Assert.That(Instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.AdapterOperation));
Assert.That(Instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
public void Disable(Feature feature, FlipperDotNet.Gate.IGate gate, object thing)
{
var instrumentationPayload = new InstrumentationPayload {
Operation = "disable",
AdapterName = Adapter.Name,
FeatureName = feature.Name,
GateName = gate.Name,
};
using (Instrumenter.InstrumentAdapter(instrumentationPayload))
{
Adapter.Disable(feature, gate, thing);
}
}
public void ShouldRecordInstrumentationWhenClearingFeature()
{
var feature = Flipper.Feature("Stats");
Adapter.Clear(feature);
var expectedPayload = new InstrumentationPayload {
Operation = "clear",
AdapterName = "memory",
FeatureName = "Stats",
};
Assert.That(Instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.AdapterOperation));
Assert.That(Instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
public void ShouldRecordInstrumentationWhenAddingFeature()
{
var feature = Flipper.Feature("Stats");
Adapter.Add(feature);
var expectedPayload = new InstrumentationPayload {
Operation = "add",
AdapterName = "memory",
FeatureName = "Stats",
};
Assert.That(Instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.AdapterOperation));
Assert.That(Instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
public System.Collections.Generic.IDictionary <string, object> Get(Feature feature)
{
var instrumentationPayload = new InstrumentationPayload {
Operation = "get",
AdapterName = Adapter.Name,
FeatureName = feature.Name,
};
using (Instrumenter.InstrumentAdapter(instrumentationPayload))
{
var result = Adapter.Get(feature);
instrumentationPayload.Result = result;
return(result);
}
}
public void ShouldRecordInstrumentationWhenDisablingFeature()
{
var feature = Flipper.Feature("Stats");
var gate = feature.PercentageOfActorsGate;
var value = 22;
Adapter.Disable(feature, gate, value);
var expectedPayload = new InstrumentationPayload {
Operation = "disable",
AdapterName = "memory",
FeatureName = "Stats",
};
Assert.That(Instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.AdapterOperation));
Assert.That(Instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
public void ShouldRecordInstrumentationForDisable()
{
var instrumenter = new MockInstrumenter();
var feature = new Feature("Name", new MemoryAdapter(), instrumenter);
feature.Disable();
var expectedPayload = new InstrumentationPayload {
FeatureName = "Name",
Operation = "disable",
Thing = false,
};
Assert.That(instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.FeatureOperation));
Assert.That(instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
private bool InstrumentGate(IGate gate, string operation, object thing, Func <IGate, bool> function)
{
var payload = new InstrumentationPayload {
FeatureName = Name,
GateName = gate.Name,
Operation = operation,
Thing = thing,
};
using (Instrumenter.InstrumentGate(payload))
{
var result = function(gate);
payload.Result = result;
return(result);
}
}
public void ShouldPublishFeatureTimingMetricForAllOperations()
{
var operationName = "Operation";
long milliseconds = 15;
var clock = MockClock(milliseconds);
var StatsdClient = MockRepository.GenerateStub<IStatsd>();
var payload = new InstrumentationPayload {
Operation = operationName,
};
var Instrumenter = new StatsdInstrumenter(StatsdClient, clock);
var token = Instrumenter.InstrumentFeature(payload);
token.Dispose();
StatsdClient.AssertWasCalled(x => x.LogTiming(string.Format("flipper.feature_operation.{0}", operationName), milliseconds));
}
public void ShouldRecordInstrumentationForDisable()
{
var instrumenter = new MockInstrumenter();
var feature = new Feature("Name", new MemoryAdapter(), instrumenter);
feature.Disable();
var expectedPayload = new InstrumentationPayload {
FeatureName = "Name",
GateName = feature.BooleanGate.Name,
Operation = "disable",
Thing = false,
};
Assert.That(instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.FeatureOperation));
Assert.That(instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
public void ShouldPublishFeatureTimingMetricForAllOperations()
{
var operationName = "Operation";
long milliseconds = 15;
var clock = MockClock(milliseconds);
var StatsdClient = MockRepository.GenerateStub <IStatsd>();
var payload = new InstrumentationPayload {
Operation = operationName,
};
var Instrumenter = new StatsdInstrumenter(StatsdClient, clock);
var token = Instrumenter.InstrumentFeature(payload);
token.Dispose();
StatsdClient.AssertWasCalled(x => x.LogTiming(string.Format("flipper.feature_operation.{0}", operationName), milliseconds));
}
public void ShouldPublishFeatureCountMetricForIsEnabledOperation(bool isEnabled, string status)
{
var featureName = "Feature";
var operationName = "enabled?";
var StatsdClient = MockRepository.GenerateStub<IStatsd>();
var payload = new InstrumentationPayload {
FeatureName = featureName,
Operation = operationName,
Result = isEnabled,
};
var Instrumenter = new StatsdInstrumenter(StatsdClient);
var token = Instrumenter.InstrumentFeature(payload);
token.Dispose();
StatsdClient.AssertWasCalled(x => x.LogCount(string.Format("flipper.feature.{0}.{1}", featureName, status)));
}
public void ShouldStripQuestionMarkFromOperationName()
{
var operationName = "Operation?";
var expectedOperationName = "Operation";
var StatsdClient = MockRepository.GenerateStub<IStatsd>();
var payload = new InstrumentationPayload {
Operation = operationName,
};
var Instrumenter = new StatsdInstrumenter(StatsdClient);
var token = Instrumenter.InstrumentFeature(payload);
token.Dispose();
StatsdClient.AssertWasCalled(x => x.LogTiming(
Arg<string>.Is.Equal(string.Format("flipper.feature_operation.{0}", expectedOperationName)),
Arg<long>.Is.Anything));
}
public void ShouldRecordInstrumentationForEnable()
{
var instrumenter = new MockInstrumenter();
var feature = new Feature("Name", new MemoryAdapter(), instrumenter);
var flipperActor = MockActor("User:5");
feature.EnableActor(flipperActor);
var expectedPayload = new InstrumentationPayload {
FeatureName = "Name",
Operation = "enable",
Thing = flipperActor,
};
Assert.That(instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.FeatureOperation));
Assert.That(instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
public void ShouldStripQuestionMarkFromOperationName()
{
var operationName = "Operation?";
var expectedOperationName = "Operation";
var StatsdClient = MockRepository.GenerateStub <IStatsd>();
var payload = new InstrumentationPayload {
Operation = operationName,
};
var Instrumenter = new StatsdInstrumenter(StatsdClient);
var token = Instrumenter.InstrumentFeature(payload);
token.Dispose();
StatsdClient.AssertWasCalled(x => x.LogTiming(
Arg <string> .Is.Equal(string.Format("flipper.feature_operation.{0}", expectedOperationName)),
Arg <long> .Is.Anything));
}
public void ShouldRecordInstrumentationWhenDisablingFeature()
{
var feature = Flipper.Feature("Stats");
var gate = feature.PercentageOfActorsGate;
var value = 22;
Adapter.Disable(feature, gate, value);
var expectedPayload = new InstrumentationPayload {
Operation = "disable",
AdapterName = "memory",
FeatureName = "Stats",
GateName = "percentage_of_actors",
};
Assert.That(Instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.AdapterOperation));
Assert.That(Instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
public void ShouldPublishFeatureCountMetricForIsEnabledOperation(bool isEnabled, string status)
{
var featureName = "Feature";
var operationName = "enabled?";
var StatsdClient = MockRepository.GenerateStub <IStatsd>();
var payload = new InstrumentationPayload {
FeatureName = featureName,
Operation = operationName,
Result = isEnabled,
};
var Instrumenter = new StatsdInstrumenter(StatsdClient);
var token = Instrumenter.InstrumentFeature(payload);
token.Dispose();
StatsdClient.AssertWasCalled(x => x.LogCount(string.Format("flipper.feature.{0}.{1}", featureName, status)));
}
public void ShouldRecordInstrumentationForEnable()
{
var instrumenter = new MockInstrumenter();
var feature = new Feature("Name", new MemoryAdapter(), instrumenter);
var flipperActor = MockActor("User:5");
feature.EnableActor(flipperActor);
var expectedPayload = new InstrumentationPayload {
FeatureName = "Name",
GateName = feature.ActorGate.Name,
Operation = "enable",
Thing = flipperActor,
};
Assert.That(instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.FeatureOperation));
Assert.That(instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
private void PublishFeatureMetrics(TimeSpan duration, InstrumentationPayload payload)
{
var operation = payload.Operation.TrimEnd('?');
_statsdClient.LogTiming(string.Format("flipper.feature_operation.{0}", operation), (long)duration.TotalMilliseconds);
if (payload.Operation == "enabled?")
{
var featureName = payload.FeatureName;
string metricName;
if ((bool)payload.Result)
{
metricName = string.Format("flipper.feature.{0}.enabled", featureName);
} else
{
metricName = string.Format("flipper.feature.{0}.disabled", featureName);
}
_statsdClient.LogCount(metricName);
}
}
private void Enable(IGate gate, object value)
{
var payload = new InstrumentationPayload {
FeatureName = Name,
GateName = gate.Name,
Operation = "enable",
Thing = value,
};
using (Instrumenter.InstrumentFeature(payload))
{
try
{
Adapter.Add(this);
Adapter.Enable(this, gate, gate.WrapValue(value));
} catch (Exception e)
{
throw new AdapterRequestException(string.Format("Failed to enable feature {0}", Name), e);
}
}
}
public void ShouldRecordGateInstrumentationForIsEnabledFor([Values(true, false)] Boolean enabled)
{
var instrumenter = new MockInstrumenter();
var feature = new Feature("Name", new MemoryAdapter(), instrumenter);
var flipperActor = MockActor("User:5");
if (enabled)
{
feature.EnableActor(flipperActor);
}
else
{
feature.DisableActor(flipperActor);
}
instrumenter.Events.Clear();
feature.IsEnabledFor(flipperActor);
var expectedPayload = new InstrumentationPayload {
FeatureName = "Name",
GateName = "actor",
Operation = "open?",
Thing = flipperActor,
Result = enabled,
};
if (enabled)
{
expectedPayload.GateName = feature.ActorGate.Name;
}
var expectedEvent = new MockInstrumenter.Event {
Type = InstrumentationType.GateOperation,
Payload = expectedPayload,
};
Assert.That(instrumenter.Events, Has.Member(expectedEvent));
}
private void PublishGateMetrics(TimeSpan duration, InstrumentationPayload payload)
{
var featureName = payload.FeatureName;
var gateName = payload.GateName;
var operation = payload.Operation.TrimEnd('?');
var durationMilliseconds = (long)duration.TotalMilliseconds;
_statsdClient.LogTiming(string.Format("flipper.gate_operation.{0}.{1}", gateName, operation), durationMilliseconds);
_statsdClient.LogTiming(string.Format("flipper.feature.{0}.gate_operation.{1}.{2}", featureName, gateName, operation), durationMilliseconds);
if (payload.Operation == "open?")
{
string metricName;
if ((bool)payload.Result)
{
metricName = string.Format("flipper.feature.{0}.gate.{1}.open", featureName, gateName);
} else
{
metricName = string.Format("flipper.feature.{0}.gate.{1}.closed", featureName, gateName);
}
_statsdClient.LogCount(metricName);
}
}
public IInstrumentationToken InstrumentFeature(InstrumentationPayload payload)
{
return new FeatureInstrumentationToken(this, payload, _clock);
}
public IInstrumentationToken InstrumentGate(InstrumentationPayload payload)
{
return new InstrumentationToken();
}
public GateInstrumentationToken(StatsdInstrumenter instrumenter, InstrumentationPayload payload, IClock clock)
: base(instrumenter, payload, clock)
{
}
public void ShouldRecordInstrumentationWhenLoadingFeatures()
{
var feature = Flipper.Feature("Stats");
var result = Adapter.Features;
var expectedPayload = new InstrumentationPayload {
Operation = "features",
AdapterName = "memory",
Result = result,
};
Assert.That(Instrumenter.Events.First().Type, Is.EqualTo(InstrumentationType.AdapterOperation));
Assert.That(Instrumenter.Events.First().Payload, Is.EqualTo(expectedPayload));
}
public InstrumentationToken(StatsdInstrumenter instrumenter, InstrumentationPayload payload, IClock clock)
{
_instrumenter = instrumenter;
_payload = payload;
_clock = clock;
_startTime = _clock.Now;
}
public InstrumentationToken(MockInstrumenter instrumenter, InstrumentationType type, InstrumentationPayload payload)
{
_instrumenter = instrumenter;
_type = type;
_payload = payload;
}
public void Remove(Feature feature)
{
var instrumentationPayload = new InstrumentationPayload {
Operation = "remove",
AdapterName = Adapter.Name,
FeatureName = feature.Name,
};
using (Instrumenter.InstrumentAdapter(instrumentationPayload))
{
Adapter.Remove(feature);
}
}
public IInstrumentationToken InstrumentAdapter(InstrumentationPayload payload)
{
return new AdapterInstrumentationToken(this, payload, _clock);
}
private bool IsEnabled(object thing)
{
var payload = new InstrumentationPayload {
FeatureName = Name,
Operation = "enabled?",
};
if (thing != null)
{
payload.Thing = thing;
}
using (Instrumenter.InstrumentFeature(payload))
{
bool result = Gates.Any(gate => gate.IsOpen(thing, GateValues[gate.Key], Name));
payload.Result = result;
return result;
}
}
public System.Collections.Generic.IDictionary<string, object> Get(Feature feature)
{
var instrumentationPayload = new InstrumentationPayload {
Operation = "get",
AdapterName = Adapter.Name,
FeatureName = feature.Name,
};
using (Instrumenter.InstrumentAdapter(instrumentationPayload))
{
var result = Adapter.Get(feature);
instrumentationPayload.Result = result;
return result;
}
}
public IInstrumentationToken InstrumentAdapter(InstrumentationPayload payload)
{
return(new InstrumentationToken(this, InstrumentationType.AdapterOperation, payload));
}
public IInstrumentationToken InstrumentGate(InstrumentationPayload payload)
{
return(new InstrumentationToken(this, InstrumentationType.GateOperation, payload));
}
public IInstrumentationToken InstrumentGate(InstrumentationPayload payload)
{
return new GateInstrumentationToken(this, payload, _clock);
}
private void PublishAdapterMetrics(TimeSpan duration, InstrumentationPayload payload)
{
var adapterName = payload.AdapterName;
var operation = payload.Operation;
_statsdClient.LogTiming(string.Format("flipper.adapter.{0}.{1}", adapterName, operation), (long)duration.TotalMilliseconds);
}
public InstrumentationToken(MockInstrumenter instrumenter, InstrumentationType type, InstrumentationPayload payload)
{
_instrumenter = instrumenter;
_type = type;
_payload = payload;
}
public IInstrumentationToken InstrumentAdapter(InstrumentationPayload payload)
{
return new InstrumentationToken(this, InstrumentationType.AdapterOperation, payload);
}
private void Enable(IGate gate, object value)
{
var payload = new InstrumentationPayload {
FeatureName = Name,
Operation = "enable",
Thing = value,
};
using (Instrumenter.InstrumentFeature(payload))
{
try
{
Adapter.Add(this);
Adapter.Enable(this, gate, gate.WrapValue(value));
} catch (Exception e)
{
throw new AdapterRequestException(string.Format("Failed to enable feature {0}", Name), e);
}
}
}
public IInstrumentationToken InstrumentAdapter(InstrumentationPayload payload)
{
return new InstrumentationToken();
}
public IInstrumentationToken InstrumentFeature(InstrumentationPayload payload)
{
return new InstrumentationToken(this, InstrumentationType.FeatureOperation, payload);
}
