Beispiel #1
0
        public async Task <bool> IsEnabledAsync(string featureName, string productName = null, CancellationToken cancellationToken = default)
        {
            try
            {
                var totalTime = ValueStopwatch.StartNew();

                _diagnostics.BeginFeatureEvaluation(featureName, productName);

                var feature = await _featureStore
                              .FindFeatureAsync(featureName, productName, cancellationToken);

                if (feature == null)
                {
                    _diagnostics.FeatureEvaluationNotFound(featureName, productName);
                    return(_options.NotFoundBehavior == NotFoundBehavior.SetEnabled);
                }

                if (!feature.IsEnabled)
                {
                    _diagnostics.FeatureEvaluationDisabled(featureName, productName);
                    return(false);
                }

                var enabled = true;
                var toggles = feature.GetToggles();

                foreach (var toggle in toggles)
                {
                    _diagnostics.BeginTogglevaluation(featureName, productName, toggle.Type);

                    var active         = false;
                    var evaluationTime = ValueStopwatch.StartNew();

                    var toggleInstance = _toggleActivator
                                         .CreateInstance(toggle.Type);

                    if (toggleInstance != null)
                    {
                        active = await toggleInstance?.IsActiveAsync(featureName, productName, cancellationToken);
                    }

                    _diagnostics.Togglevaluation(featureName, productName, toggle.Type, (long)evaluationTime.GetElapsedTime().TotalMilliseconds);
                    _diagnostics.EndTogglevaluation(featureName, productName, toggle.Type, active);

                    if (!active)
                    {
                        _diagnostics.ToggleNotActive(featureName, toggle.Type);

                        enabled = false;
                        break;
                    }
                }

                _diagnostics.EndFeatureEvaluation(featureName, productName, (long)totalTime.GetElapsedTime().TotalMilliseconds, enabled);

                return(enabled);
            }
            catch (Exception exception)
            {
                _diagnostics.FeatureEvaluationThrow(featureName, productName, exception);

                if (_options.OnErrorBehavior == OnErrorBehavior.Throw)
                {
                    throw;
                }

                return(_options.OnErrorBehavior == OnErrorBehavior.SetEnabled);
            }
        }
Beispiel #2
0
        public async Task <bool> IsEnabledAsync(string featureName, string productName = null, CancellationToken cancellationToken = default)
        {
            try
            {
                var totalTime = ValueStopwatch.StartNew();

                Log.FeatureServiceProcessingBegin(_logger, featureName, productName);

                var feature = await _featureStore
                              .FindFeatureAsync(featureName, productName, cancellationToken);

                if (feature == null)
                {
                    Log.FeatureServiceNotFoundFeature(_logger, featureName, productName);
                    return(_options.NotFoundBehavior == NotFoundBehavior.SetEnabled);
                }

                if (!feature.IsEnabled)
                {
                    Log.FeatureServiceDisabledFeature(_logger, featureName, productName);
                    return(false);
                }

                var enabled = true;
                var toggles = feature.GetToggles();

                foreach (var toggle in toggles)
                {
                    var active         = false;
                    var evaluationTime = ValueStopwatch.StartNew();

                    var toggleInstance = _toggleActivator
                                         .CreateInstance(toggle.Type);

                    if (toggleInstance != null)
                    {
                        active = await toggleInstance?.IsActiveAsync(featureName, productName, cancellationToken);
                    }

                    Counters.Instance
                    .ToggleEvaluationTime(
                        featureName: featureName,
                        toggleName: toggle.Type,
                        elapsedMilliseconds: evaluationTime.GetElapsedTime().TotalMilliseconds);

                    if (!active)
                    {
                        Log.FeatureServiceToggleIsNotActive(_logger, featureName, productName);
                        enabled = false;
                        break;
                    }
                }

                Counters.Instance
                .FeatureEvaluationTime(
                    featureName: featureName,
                    elapsedMilliseconds: totalTime.GetElapsedTime().TotalMilliseconds);

                return(enabled);
            }
            catch (Exception exception)
            {
                Log.FeatureServiceProcessingFail(_logger, featureName, productName, exception);

                if (_options.OnErrorBehavior == OnErrorBehavior.Throw)
                {
                    throw;
                }

                return(_options.OnErrorBehavior == OnErrorBehavior.SetEnabled);
            }
        }