public Task <Counter> GetCounter(string product, PeriodKind periodKind = PeriodKind.Daily, DateTimeOffset?periodStart = null,
CounterKind kind = CounterKind.Total)
{
periodStart = periodStart == null
? DateTimeOffset.Now.Date
: periodStart.Value.Date;
int dayOffset = 0;
var calendar = CultureInfo.GetCultureInfo("ru-RU").Calendar;
switch (periodKind)
{
case PeriodKind.Daily:
dayOffset = 0;
break;
case PeriodKind.Weekly:
var dayOfWeek = calendar.GetDayOfWeek(periodStart.Value.DateTime);
dayOffset = DayOfWeek.Monday - dayOfWeek;
if (dayOffset > 0)
{
dayOffset -= 7;
}
break;
case PeriodKind.Monthly:
dayOffset = periodStart.Value.Day == 1 ? 0 : 1 - periodStart.Value.Day;
break;
}
return(_dataStorage.GetCounterOrDefault(product, periodKind, calendar.AddDays(periodStart.Value.DateTime, dayOffset), kind));
}
protected Counter(string category, string name, CounterType type, CounterLevel level, CounterKind kind, CounterUnit unit)
{
Category = category;
Name = name;
Type = type;
Level = level;
Kind = kind;
Unit = unit;
}
public async Task <Counter> Get(string product, PeriodKind periodKind = PeriodKind.Daily, DateTimeOffset?periodStart = null, CounterKind counterKind = CounterKind.Total)
{
return(await _counterQuery.GetCounter(product, periodKind, periodStart, counterKind));
}
/// <summary>
/// Initializes a new instance of the <see cref="CounterDescription"/> struct.
/// </summary>
/// <param name="counterKind">Type of query (see <see cref="CounterKind"/>).</param>
/// <param name="miscFlags">Miscellaneous flags.</param>
public CounterDescription(CounterKind counterKind, int miscFlags = 0)
{
CounterKind = counterKind;
MiscFlags = miscFlags;
}
public static CounterItem <T> Retrieve(string category, string name, CounterType type, CounterLevel level, CounterKind kind, CounterUnit unit, List <CounterItemValue <T> > values)
{
var item = ReferencePool <CounterItem <T> > .Shared.New();
item.Environment = Core.EnvironmentName;
item.Application = Core.ApplicationName;
item.Category = category;
item.Name = name;
item.Type = type;
item.Level = level;
item.Kind = kind;
item.Unit = unit;
item.Values = values;
return(item);
}
internal DecimalCounter(string category, string name, CounterType type, CounterLevel level, CounterKind kind, CounterUnit unit) : base(category, name, type, level, kind, unit)
{
}
public async Task <Counter> GetCounterOrDefault(string product, PeriodKind periodKind, DateTimeOffset periodStart, CounterKind counterKind)
{
var counter = (await
_conn.QueryAsync <Counter>(
"select top 1 * from Counter where Product=@product and PeriodStart=@periodStart and PeriodKind=@periodKind and CounterKind=@counterKind",
new { product, periodKind, periodStart = periodStart.Date, counterKind })).SingleOrDefault();
return(counter ?? new Counter
{
Product = product,
Kind = counterKind,
PeriodStart = periodStart,
PeriodKind = periodKind
});
}
public static ServiceDescriptor GetDescriptor(Type serviceType, string counterCategory = null, CounterLevel counterLevel = CounterLevel.User, CounterKind counterKind = CounterKind.Application)
{
var descriptor = new ServiceDescriptor
{
Name = serviceType.FullName
};
var isInterface = serviceType.IsInterface;
var methodsInfo = serviceType.AllMethods().OrderBy(i => i.Name + "[" + i.GetParameters()?.Select(p => p.Name).Join(", ") + "]");
foreach (var mInfo in methodsInfo)
{
if (!mInfo.IsPublic || mInfo.IsSpecialName)
{
continue;
}
var isRpcMethod = mInfo.IsDefined(typeof(RPCMethodAttribute)) || isInterface;
if (!isRpcMethod)
{
continue;
}
var mDesc = new MethodDescriptor
{
Method = mInfo.GetMethodAccessor(),
Name = mInfo.Name,
ReturnType = GetTypeName(mInfo.ReturnType),
TypeOfReturnType = mInfo.ReturnType
};
if (mInfo.ReturnType == typeof(Task) || mInfo.ReturnType.BaseType == typeof(Task))
{
mDesc.ReturnIsTask = true;
if (mInfo.ReturnType.GenericTypeArguments.Length > 0)
{
mDesc.ReturnTaskResult = mInfo.ReturnType.GetProperty("Result").GetFastPropertyInfo();
mDesc.CreateTaskFromResult = typeof(Task).GetMethod("FromResult").MakeGenericMethod(new[] { mInfo.ReturnType.GenericTypeArguments[0] }).GetMethodAccessor();
}
else
{
mDesc.ReturnTaskResult = null;
mDesc.CreateTaskFromResult = null;
}
}
if (counterCategory != null)
{
mDesc.Counter = Core.Counters.GetDoubleCounter(counterCategory, serviceType.FullName + "\\" + mDesc.Name, CounterType.Average, counterLevel, counterKind, CounterUnit.Milliseconds);
}
RegisterServiceDescriptorType(descriptor, mInfo.ReturnType);
var pars = mInfo.GetParameters();
mDesc.Parameters = new ParameterDescriptor[pars.Length];
for (var i = 0; i < pars.Length; i++)
{
var p = pars[i];
var pDes = new ParameterDescriptor
{
Parameter = p,
Name = p.Name,
Index = p.Position,
Type = GetTypeName(p.ParameterType)
};
RegisterServiceDescriptorType(descriptor, p.ParameterType);
mDesc.Parameters[i] = pDes;
}
mDesc.Id = GetMethodId(descriptor, mDesc);
descriptor.Methods.Add(mDesc.Id, mDesc);
}
var eventsInfo = serviceType.GetRuntimeEvents();
foreach (var eInfo in eventsInfo)
{
if (eInfo.IsSpecialName)
{
continue;
}
var isRpcEvent = eInfo.IsDefined(typeof(RPCEventAttribute)) || isInterface;
if (!isRpcEvent)
{
continue;
}
var name = eInfo.Name;
var eventHandler = GetTypeName(eInfo.EventHandlerType);
RegisterServiceDescriptorType(descriptor, eInfo.EventHandlerType);
descriptor.Events.Add(name, new EventDescriptor {
Name = name, Type = eventHandler, Event = eInfo
});
}
return(descriptor);
}
/// <summary>
/// Initializes a new instance of the <see cref="CounterDescription"/> struct.
/// </summary>
/// <param name="counterKind">Type of query (see <see cref="CounterKind"/>).</param>
public CounterDescription(CounterKind counterKind)
{
CounterKind = counterKind;
MiscFlags = 0;
}
