private static void AddEventRow(StringBuilder sb, StatsEvent ev)
{
var eventView = new EventViewModel((StEvent)ev.Event, ev.UserId, ev.Time, (DeviceType)ev.DeviceType);
sb.Append(ev.Id);
sb.Append(";");
sb.Append(ev.Event);
sb.Append(";");
sb.Append("\"" + eventView.evt + "\"");
sb.Append(";");
sb.Append(ev.DiscussionId);
sb.Append(";");
sb.Append("\"" + ev.DiscussionName + "\"");
sb.Append(";");
sb.Append(ev.TopicId);
sb.Append(";");
sb.Append("\"" + ev.TopicName + "\"");
sb.Append(";");
sb.Append(ev.UserId);
sb.Append(";");
sb.Append("\"" + ev.UserName + "\"");
sb.Append(";");
sb.Append(ev.Time.ToString("dd.MM.yyyy HH:mm:ss"));
sb.Append(";");
sb.Append(ev.DeviceType);
sb.Append(";");
sb.AppendLine("\"" + eventView.devType + "\"");
}
private static void AssertSerialize(
string expectValue,
string title = null,
string text = null,
string alertType = null,
string aggregationKey = null,
string sourceType = null,
int?dateHappened = null,
string priority = null,
string hostname = null,
string[] tags = null,
bool truncateIfTooLong = false)
{
var serializer = CreateSerializer();
var statsEvent = new StatsEvent
{
Title = title,
Text = text,
AlertType = alertType,
AggregationKey = aggregationKey,
SourceType = sourceType,
DateHappened = dateHappened,
Priority = priority,
Hostname = hostname,
TruncateIfTooLong = truncateIfTooLong,
Tags = tags,
};
var serializedMetric = new SerializedMetric();
serializer.SerializeTo(ref statsEvent, serializedMetric);
Assert.AreEqual(expectValue, serializedMetric.ToString());
}
public static bool Log(DiscCtx ctx, StEvent e, int userId, int discussionId, int topicId, DeviceType devType)
{
var pers = ctx.Person.FirstOrDefault(p0 => p0.Id == userId);
if (pers == null && userId != -1)
{
return(false);
}
var disc = ctx.Discussion.FirstOrDefault(d0 => d0.Id == discussionId);
if (disc == null)
{
return(false);
}
var topic = ctx.Topic.FirstOrDefault(t0 => t0.Id == topicId);
if (topic == null)
{
return(false);
}
if (!topic.Running && e != StEvent.RecordingStarted &&
e != StEvent.RecordingStopped)
{
return(false);
}
var s = new StatsEvent
{
DiscussionId = discussionId,
DiscussionName = disc.Subject,
TopicId = topicId,
TopicName = topic.Name,
UserId = userId
};
if (pers != null)
{
s.UserName = pers.Name;
}
else
{
s.UserName = "******";
}
s.Event = (int)e;
s.Time = DateTime.Now;
s.DeviceType = (int)devType;
ctx.AddToStatsEvent(s);
ctx.SaveChanges();
return(true);
}
public void SerializeTo(ref StatsEvent statsEvent, SerializedMetric serializedMetric)
{
serializedMetric.Reset();
string processedTitle = SerializerHelper.EscapeContent(statsEvent.Title);
string processedText = SerializerHelper.EscapeContent(statsEvent.Text);
var builder = serializedMetric.Builder;
builder.Append("_e{");
builder.AppendFormat(CultureInfo.InvariantCulture, "{0}", processedTitle.Length);
builder.Append(',');
builder.AppendFormat(CultureInfo.InvariantCulture, "{0}", processedText.Length);
builder.Append("}:");
builder.Append(processedTitle);
builder.Append('|');
builder.Append(processedText);
if (statsEvent.DateHappened != null)
{
builder.AppendFormat(CultureInfo.InvariantCulture, "|d:{0}", statsEvent.DateHappened.Value);
}
SerializerHelper.AppendIfNotNull(builder, "|h:", statsEvent.Hostname);
SerializerHelper.AppendIfNotNull(builder, "|k:", statsEvent.AggregationKey);
SerializerHelper.AppendIfNotNull(builder, "|p:", statsEvent.Priority);
SerializerHelper.AppendIfNotNull(builder, "|s:", statsEvent.SourceType);
SerializerHelper.AppendIfNotNull(builder, "|t:", statsEvent.AlertType);
_serializerHelper.AppendTags(builder, statsEvent.Tags);
if (builder.Length > MaxSize)
{
if (statsEvent.TruncateIfTooLong)
{
var overage = builder.Length - MaxSize;
if (statsEvent.Title.Length > statsEvent.Text.Length)
{
statsEvent.Title = SerializerHelper.TruncateOverage(statsEvent.Title, overage);
}
else
{
statsEvent.Text = SerializerHelper.TruncateOverage(statsEvent.Text, overage);
}
statsEvent.TruncateIfTooLong = true;
SerializeTo(ref statsEvent, serializedMetric);
}
else
{
throw new Exception(string.Format("Event {0} payload is too big (more than 8kB)", statsEvent.Title));
}
}
}
private void RaiseCommStatsUpdateEvent(object sender, CommStatsEventArgs args)
{
CommStats = args;
StatsEvent?.Invoke(this, new CommStatsEventArgs()
{
ID = CommStats.ID,
CompleteProfilesReceived = CommStats.CompleteProfilesReceived,
ProfileRate = CommStats.ProfileRate,
BytesReceived = CommStats.BytesReceived,
Evicted = CommStats.Evicted,
DataRate = CommStats.DataRate,
BadPackets = CommStats.BadPackets,
GoodPackets = CommStats.GoodPackets
});
}
private void StatsThread()
{
long lastCheck = timeBase.ElapsedMilliseconds;
long bytesReceivedSinceLastCheck = 0;
long profilesReceivedSinceLastCheck = 0;
while (true)
{
try
{
token.ThrowIfCancellationRequested();
Task.Delay(200, token).Wait(token);
long now = timeBase.ElapsedMilliseconds;
double dataRate = (bytesReceived - bytesReceivedSinceLastCheck) * 1000.0 / (now - lastCheck);
long profileRate = (CompleteProfilesReceivedCount - profilesReceivedSinceLastCheck) * 1000 /
(now - lastCheck);
commStats.ID = scanHead.ID;
commStats.CompleteProfilesReceived = CompleteProfilesReceivedCount;
commStats.ProfileRate = profileRate;
commStats.BytesReceived = bytesReceived;
commStats.Evicted = evictedForTimeout + IncompleteProfilesReceivedCount;
commStats.DataRate = dataRate;
commStats.BadPackets = BadPacketsCount;
commStats.GoodPackets = goodPackets;
StatsEvent?.Invoke(this, new CommStatsEventArgs()
{
ID = commStats.ID,
CompleteProfilesReceived = commStats.CompleteProfilesReceived,
ProfileRate = commStats.ProfileRate,
BytesReceived = commStats.BytesReceived,
Evicted = commStats.Evicted,
DataRate = commStats.DataRate,
BadPackets = commStats.BadPackets,
GoodPackets = commStats.GoodPackets
});
lastCheck = now;
bytesReceivedSinceLastCheck = bytesReceived;
profilesReceivedSinceLastCheck = CompleteProfilesReceivedCount;
}
catch (OperationCanceledException)
{
break;
}
}
}
static bool EventPassesFilter(StatsEvent ev, List <ReportParameters> reportParams)
{
bool userTest = reportParams.Any(p => p.requiredUsers.Contains(ev.UserId));
if (!userTest)
{
return(false);
}
if (ev.TopicId == -1)
{
return(true);
}
return(reportParams.Any(p => p.topic.Id == ev.TopicId));
}
public void SendEventWithMessageThatIsTooLong()
{
var length = (8 * 1024) - 16; // 16 is the number of characters in the final message that is not the title
var builder = BuildLongString(length);
var title = builder;
var serializer = CreateSerializer();
var exception = Assert.Throws <Exception>(
() =>
{
var statsEvent = new StatsEvent {
Title = title + "x", Text = "Text"
};
serializer.SerializeTo(ref statsEvent, new SerializedMetric());
});
Assert.That(exception.Message, Contains.Substring("payload is too big"));
}
public override void OnActionReceived(ActionBuffers actionBuffers)
{
var actions = actionBuffers.ContinuousActions.Array;
vehicle.Motor.value = actions[0];
vehicle.Steering.value = actions[1];
Vector3 fwd = vehicle.transform.forward;
Vector3 pos = vehicle.transform.position;
bool chunkAdded = road.OnUpdate(pos);
Frame frame = road.AgentFrame;
stats.action0 = actions[0];
stats.action1 = actions[1];
stats.speed = Vector3.Dot(frame.Forward, vehicle.Rigidbody.velocity);
stats.steer = vehicle.Steering.CrntNormValue;
stats.offset = frame.LocalPosition(pos).x;
stats.orientation = Vector3.SignedAngle(frame.Forward, fwd, frame.Up);
stats.collisions = vehicle.CollisionCount;
vehicle.CollisionCount = 0;
updateTime = chunkAdded ? Time.time : updateTime;
bool hasTimedOut = Time.time - updateTime > timeout;
if (hasTimedOut || IsOffMesh())
{
AddReward(-1);
ResetAgent();
}
else
{
float offRoad = Mathf.Abs(stats.offset) - Chunk.RoadExtent + 1;
stats.reward = offRoad > 0 ? -offRoad : stats.speed * 0.02f;
stats.reward -= stats.collisions * 0.5f;
AddReward(stats.reward);
}
StatsEvent?.Invoke(name, stats);
}
private TreeViewItem GetEvent(StatsEvent e, DiscCtx ctx)
{
var res = new TreeViewItem();
var eventView = new EventViewModel((StEvent)e.Event, e.UserId, e.Time, (DeviceType)e.DeviceType);
res.Header = eventView.evt;
res.Items.Add(GetUser(ctx.Person.FirstOrDefault(p0 => p0.Id == e.UserId)));
if (!string.IsNullOrEmpty(e.TopicName))
{
res.Items.Add(e.TopicName);
}
if (!string.IsNullOrEmpty(e.DiscussionName))
{
res.Items.Add(e.DiscussionName);
}
res.Items.Add(eventView.dateTime);
res.Items.Add(eventView.devType);
return(res);
}
public static void recordEvent(TimelineEvent evt, DateTime startTime)
{
var _ctx = DbCtx.Get();
var pers = _ctx.Person.FirstOrDefault(p0 => p0.Id == evt.userId);
var disc = _ctx.Discussion.FirstOrDefault(d0 => d0.Id == evt.discussionId);
if (disc == null)
{
return;
}
var topic = _ctx.Topic.FirstOrDefault(t0 => t0.Id == evt.topicId);
var s = new StatsEvent();
s.DiscussionId = evt.discussionId;
s.DiscussionName = disc.Subject;
s.TopicId = evt.topicId;
if (topic != null)
{
s.TopicName = topic.Name;
}
else
{
s.TopicName = "";
}
s.UserId = evt.userId;
s.UserName = pers.Name;
s.Event = (int)evt.e;
s.Time = startTime.Add(evt.Span);
s.DeviceType = (int)evt.devType;
_ctx.AddToStatsEvent(s);
}
public StatsCollectRequestBuilder(StatsEvent kevent)
: this()
{
this.Kevent = kevent;
}
public static StatsCollectRequestBuilder Collect(StatsEvent kevent)
{
return(new StatsCollectRequestBuilder(kevent));
}
