////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public CacheManager(IMetricsManager pMetrics)
{
Memory = new MemCache(pMetrics);
RexConn = new RexConnCacheProvider();
pMetrics.Gauge("cache.rc.keys", CountRexConnKeys);
}
internal Batch(ISession session, BatchType batchType)
{
_session = session;
_metricsManager = (session as IInternalSession)?.MetricsManager;
_batchType = batchType;
QueryAbortTimeout = session.Cluster.Configuration.DefaultRequestOptions.QueryAbortTimeout;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void LogResponse(IApiRequest pApiReq)
{
IOperationContext oc = pApiReq.OpCtx;
long totalMs = (long)GetTimerMilliseconds();
long jsonLen = (Json == null ? 0 : Json.Length);
ThreadPool.QueueUserWorkItem(w => {
try {
oc.Analytics.TrackRequest(pApiReq.Method, pApiReq.Path);
}
catch (Exception e) {
Log.Error("Analytics failure", e);
}
});
////
IMetricsManager m = oc.Metrics;
string key = BuildGraphiteKey(pApiReq);
m.Counter(key, 1);
m.Counter(key + ".requests", 1);
m.Counter(key + ".errors", (IsError ? 1 : 0));
m.Timer(key + ".total-ms", totalMs);
m.Mean(key + ".json-len", jsonLen);
if (oc.Data.DbQueryExecutionCount > 0)
{
m.Timer(key + ".db", oc.Data.DbQueryMillis);
m.Mean(key + ".db.queries", oc.Data.DbQueryExecutionCount);
}
//ARv1: (ApiResponse log, version 1)
// IP, QueryCount, TotalMs, JsonLen, Timestamp, HttpStatus, IsError, Method, Path, Exception
const string name = "ARv1";
const string x = " | ";
string ctxId = Logger.GuidToString(oc.ContextId);
string v1 =
pApiReq.IpAddress + x +
oc.Data.DbQueryExecutionCount + x +
totalMs + x +
jsonLen + x +
DateTime.UtcNow.Ticks + x +
(int)Status + x +
(IsError ? 1 : 0) + x +
pApiReq.Method + x +
pApiReq.Path;
if (Unhandled == null)
{
Log.Info(ctxId, name, v1);
}
else
{
Log.Error(ctxId, name, v1, Unhandled);
}
}
internal Mapper(ISession session, MapperFactory mapperFactory, StatementFactory statementFactory, CqlGenerator cqlGenerator)
{
_session = session ?? throw new ArgumentNullException(nameof(session));
_metricsManager = (session as IInternalSession)?.MetricsManager;
_mapperFactory = mapperFactory ?? throw new ArgumentNullException(nameof(mapperFactory));
_statementFactory = statementFactory ?? throw new ArgumentNullException(nameof(statementFactory));
_cqlGenerator = cqlGenerator ?? throw new ArgumentNullException(nameof(cqlGenerator));
_queryAbortTimeout = session.Cluster.Configuration.DefaultRequestOptions.QueryAbortTimeout;
}
public MetricFilter(
IMetricsManager <Metric> metricManager,
IClientIpAddress clientIpAddress,
IFeatureFacade featureFacade,
IPageTitleBuilder pageTitleBuilder)
{
_metricManager = metricManager;
_clientIpAddress = clientIpAddress;
_featureFacade = featureFacade;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public OperationData(Guid pContextId, IDataAccessFactory pFactory,
IMetricsManager pMetrics, IMemCache pCache)
{
vContextId = pContextId;
vFactory = pFactory;
vMetrics = pMetrics;
vCache = pCache;
DbQueryExecutionCount = 0;
DbQueryMillis = 0;
}
//private readonly Stopwatch vProfiler;
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public OperationContext(IDataAccessFactory pAccessFactory, ICacheManager pCache,
IMetricsManager pMetrics, Func <Guid, IAnalyticsManager> pAnalyticsProvider)
{
Metrics = pMetrics;
Cache = pCache;
ContextId = Guid.NewGuid();
Data = new OperationData(ContextId, pAccessFactory, Metrics, Cache.Memory);
Auth = new OperationAuth(Cache.Memory, () => Data.Build(), () => UtcNow.Ticks);
Analytics = pAnalyticsProvider(ContextId);
//vProfiler = new Stopwatch();
//vProfiler.Start();
}
public void TestInit()
{
_dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
_filterManager = Mock.Create<IFilterManager>(Behavior.Loose);
_layoutManager = Mock.Create<ILayoutManager>(Behavior.Loose);
_searchUtils = Mock.Create<ISearchUtils>(Behavior.Loose);
_processMetadataRepository = Mock.Create<IProcessMetadataRepository>(Behavior.Loose);
_filterDescriptorFactory = Mock.Create<IFilterDescriptorFactory>(Behavior.Loose);
_metricsManager = Mock.Create<IMetricsManager>(Behavior.Loose);
_kpiManager = Mock.Create<IKPIManager>(Behavior.Loose);
_filterRepository = Mock.Create<IFilterRepository>(Behavior.Loose);
_processMetadata = Mock.Create<IProcessMetadata>(Behavior.Loose);
Mock.Arrange(() => _processMetadata.Name).Returns(ProcessName);
Mock.Arrange(() => _processMetadataRepository.GetProcessMetadata(ProcessName)).Returns(_processMetadata);
}
/// <summary>
/// Increments session client timeout counter in case of timeout.
/// </summary>
public static void WaitToCompleteWithMetrics(IMetricsManager manager, Task task, int timeout = Timeout.Infinite)
{
if (!(manager?.AreMetricsEnabled ?? false))
{
TaskHelper.WaitToComplete(task, timeout);
return;
}
try
{
TaskHelper.WaitToComplete(task, timeout);
}
catch (TimeoutException)
{
manager.GetSessionMetrics().CqlClientTimeouts.Increment();
throw;
}
}
public IObserverFactory Build(IMetricsManager manager)
{
return(new NullObserverFactory());
}
public MetricsObserverFactory(IMetricsManager metricsManager)
{
_metricsManager = metricsManager;
}
/// <summary>
/// Increments session client timeout counter in case of timeout.
/// </summary>
public static T WaitToCompleteWithMetrics <T>(IMetricsManager manager, Task <T> task, int timeout = Timeout.Infinite)
{
TaskHelper.WaitToCompleteWithMetrics(manager, (Task)task, timeout);
return(task.Result);
}
public IObserverFactory Build(IMetricsManager manager)
{
return(new MetricsObserverFactory(manager));
}
/// <summary>
/// Initializes a new instance of the <see cref="SearchCommand"/> class.
/// </summary>
/// <param name="process">
/// The process metadata.
/// </param>
/// <param name="dynamicTypeManager">
/// The dynamic type manager.
/// </param>
/// <param name="filterManager">
/// The filter manager.
/// </param>
/// <param name="layoutManager">
/// The layout manager.
/// </param>
/// <param name="searchUtils">
/// The search utils.
/// </param>
/// <param name="filterDescriptorFactory">
/// The filter descriptor factory.
/// </param>
/// <param name="metricsManager">
/// The metrics manager.
/// </param>
/// <param name="kpiManager">
/// The KPI manager.
/// </param>
/// <param name="filterRepository">
/// The filter repository.
/// </param>
public SearchCommand(
IProcessMetadata process,
IDynamicTypeManager dynamicTypeManager,
IFilterManager filterManager,
ILayoutManager layoutManager,
ISearchUtils searchUtils,
IFilterDescriptorFactory filterDescriptorFactory,
IMetricsManager metricsManager,
IKPIManager kpiManager,
IFilterRepository filterRepository)
{
if (process == null)
throw new ArgumentNullException("process");
if (dynamicTypeManager == null)
throw new ArgumentNullException("dynamicTypeManager");
if (filterManager == null)
throw new ArgumentNullException("filterManager");
if (layoutManager == null)
throw new ArgumentNullException("layoutManager");
if (searchUtils == null)
throw new ArgumentNullException("searchUtils");
if (filterDescriptorFactory == null)
throw new ArgumentNullException("filterDescriptorFactory");
if (metricsManager == null)
throw new ArgumentNullException("metricsManager");
if (kpiManager == null)
throw new ArgumentNullException("kpiManager");
if (filterRepository == null)
throw new ArgumentNullException("filterRepository");
_dynamicTypeManager = dynamicTypeManager;
_filterManager = filterManager;
_layoutManager = layoutManager;
_searchUtils = searchUtils;
_filterDescriptorFactory = filterDescriptorFactory;
_metricsManager = metricsManager;
_kpiManager = kpiManager;
_filterRepository = filterRepository;
_process = process;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public MemCache(IMetricsManager pMetrics) : base("MemCache", GetConfig())
{
vMetrics = pMetrics;
}
public MetricsRequestObserver(IMetricsManager manager, IDriverTimer requestTimer)
{
_manager = manager;
_requestTimer = requestTimer;
}
