public async Task <IEnumerable <TraceHistogram> > GetTraceHistogram(TraceQuery traceQuery) { traceQuery.Ensure(); var index = Indices.Index(_indexManager.CreateTracingIndex()); var query = BuildTracesQuery(traceQuery); var timeSpan = traceQuery.FinishTimestamp.Value - traceQuery.StartTimestamp.Value; var histogramAggregationsResult = await _elasticClient.SearchAsync <Span>(s => s.Index(index).Size(0).Query(query). Aggregations(a => a.DateHistogram("data_histogram_startTimestamp", d => d.Field(f => f.StartTimestamp).Interval(DateInterval.Minute).Format("yyyy-MM-dd HH:mm:ss"). Aggregations(sub => sub.Cardinality("cardinality_traceId", c => c.Field(f => f.TraceId)))))); var histogramAggregations = histogramAggregationsResult.Aggregations.FirstOrDefault().Value as BucketAggregate; if (histogramAggregations == null || histogramAggregations.Items == null || !histogramAggregations.Items.OfType <DateHistogramBucket>().Any()) { return(new TraceHistogram[0]); } var traceHistograms = histogramAggregations.Items.OfType <DateHistogramBucket>().Select(x => new TraceHistogram { Time = GetHistogramTime((long)x.Key), Count = GetTraceCount(x) }); return(traceHistograms.OrderBy(x => x.Time).ToList()); }
public async Task <PageViewModel <TraceViewModel> > Get( [FromQuery] string service, [FromQuery] string tags, [FromQuery] DateTime?startTimestamp, [FromQuery] DateTime?finishTimestamp, [FromQuery] int?minDuration, [FromQuery] int?maxDuration, [FromQuery] int?pageNumber, [FromQuery] int?pageSize) { var query = new TraceQuery { Tags = tags, ServiceName = service, StartTimestamp = startTimestamp?.ToUniversalTime(), FinishTimestamp = finishTimestamp?.ToUniversalTime(), MinDuration = minDuration, MaxDuration = maxDuration, CurrentPageNumber = pageNumber.GetValueOrDefault(1), PageSize = pageSize.GetValueOrDefault(10) }; var data = await _spanQuery.GetTraces(query); var pageViewModel = _mapper.Map <PageViewModel <TraceViewModel> >(data); foreach (var traceViewModel in pageViewModel.Data) { var trace = data.Data.FirstOrDefault(x => x.TraceId == traceViewModel.TraceId); traceViewModel.Services = GetTraceServices(trace); } return(pageViewModel); }
public Task <PageResult <Trace> > GetTraces(TraceQuery traceQuery) { var query = _dbContext.Spans.AsNoTracking().Include(x => x.Tags).OrderByDescending(x => x.StartTimestamp).AsQueryable(); if (traceQuery.StartTimestamp != null) { query = query.Where(x => x.StartTimestamp >= traceQuery.StartTimestamp); } if (traceQuery.FinishTimestamp != null) { query = query.Where(x => x.FinishTimestamp <= traceQuery.FinishTimestamp); } var queryTags = BuildQueryTags(traceQuery).ToList(); if (queryTags.Any()) { var traceIdsQuery = query; foreach (var item in queryTags) { var tag = item; traceIdsQuery = traceIdsQuery.Where(x => x.Tags.Any(t => t.Key == tag.Key && t.Value == tag.Value)); } var traceIds = traceIdsQuery.Select(x => x.TraceId).Distinct().ToList(); query = query.Where(x => traceIds.Contains(x.TraceId)); } var queryGroup = query.ToList().GroupBy(x => x.TraceId); //todo fix // if (traceQuery.MinDuration != null) // { // queryGroup = queryGroup.Where(x => x.Sum(s => s.Duration) >= traceQuery.MinDuration); // } // // if (traceQuery.MaxDuration != null) // { // queryGroup = queryGroup.Where(x => x.Sum(s => s.Duration) <= traceQuery.MaxDuration); // } var totalMemberCount = queryGroup.Count(); queryGroup = queryGroup.Skip((traceQuery.CurrentPageNumber - 1) * traceQuery.PageSize).Take(traceQuery.PageSize); return(Task.FromResult(new PageResult <Trace>() { CurrentPageNumber = traceQuery.CurrentPageNumber, PageSize = traceQuery.PageSize, TotalMemberCount = totalMemberCount, TotalPageCount = (int)Math.Ceiling((double)totalMemberCount / (double)traceQuery.PageSize), Data = queryGroup.ToList().Select(x => new Trace() { TraceId = x.Key, Spans = _mapper.Map <List <Span> >(x.ToList()) }).ToList() })); }
private List <Tag> BuildQueryTags(TraceQuery traceQuery) { var tagList = new List <Tag>(); if (!string.IsNullOrEmpty(traceQuery.ServiceName)) { tagList.Add(new Tag { Key = QueryConstants.Service, Value = traceQuery.ServiceName }); return(tagList); } if (!string.IsNullOrEmpty(traceQuery.Tags)) { var tags = traceQuery.Tags.Split('|'); foreach (var tag in tags) { var pair = tag.Split('='); if (pair.Length == 2) { tagList.Add(new Tag { Key = pair[0], Value = pair[1] }); } } } return(tagList); }
public async Task <IEnumerable <TraceHistogram> > GetTraceHistogram(TraceQuery traceQuery) { var sql = "select TOP (@Limit) cast(StartTimestamp as date) [Date], Datepart(hour, StartTimestamp) [Hour], DATEPART(minute, StartTimestamp) [Minute], Count(1)[Count]" + " from Spans" + " group by cast(StartTimestamp as date), Datepart(hour, StartTimestamp), DATEPART(minute, StartTimestamp)" + " order by 1, 2, 3"; using (var conn = await GetConnectionAsync()) using (var cmd = new SqlCommand(sql, conn)) { cmd.Parameters.AddWithValue("Limit", traceQuery.Limit); using (var reader = await cmd.ExecuteReaderAsync()) { var histograms = new List <TraceHistogram>(); while (await reader.ReadAsync()) { var histogram = new TraceHistogram(); histogram.Time = DateTimeOffset.Parse($"{reader.GetDateTime(0).ToShortDateString()} {reader.GetInt32(1):00}:{reader.GetInt32(2):00}"); histogram.Count = reader.GetInt32(3); histograms.Add(histogram); } return(histograms); } } }
public async Task <IEnumerable <TraceViewModel> > Get( [FromQuery] string service, [FromQuery] string tags, [FromQuery] long?startTimestamp, [FromQuery] long?finishTimestamp, [FromQuery] int?minDuration, [FromQuery] int?maxDuration, [FromQuery] int?limit) { var query = new TraceQuery { Tags = tags, ServiceName = service, StartTimestamp = TimestampHelpers.Convert(startTimestamp), FinishTimestamp = TimestampHelpers.Convert(finishTimestamp), MinDuration = minDuration, MaxDuration = maxDuration, Limit = limit.GetValueOrDefault(10) }; var data = await _spanQuery.GetTraces(query); var traceViewModels = _mapper.Map <List <TraceViewModel> >(data); foreach (var trace in traceViewModels) { var item = data.FirstOrDefault(x => x.TraceId == trace.TraceId); trace.Services = GetTraceServices(item); } return(traceViewModels); }
public async Task <IEnumerable <Trace> > GetTraces(TraceQuery traceQuery) { var index = Indices.Index(_indexManager.CreateTracingIndex()); var query = BuildTracesQuery(traceQuery); var traceIdsAggregationsResult = await _elasticClient.SearchAsync <Span>(s => s.Index(index).Size(0).Query(query). Aggregations(a => a.Terms("group_by_traceId", t => t.Aggregations(sub => sub.Min("min_startTimestapm", m => m.Field(f => f.StartTimestamp))).Field(f => f.TraceId).Order(o => o.Descending("min_startTimestapm")).Size(traceQuery.Limit)))); var traceIdsAggregations = traceIdsAggregationsResult.Aggregations.FirstOrDefault().Value as BucketAggregate; if (traceIdsAggregations == null) { return(new Trace[0]); } var KeyedBuckets = traceIdsAggregations.Items.OfType <KeyedBucket <object> >(); var traceIds = traceIdsAggregations.Items.OfType <KeyedBucket <object> >().Where(x => x.Key != null).Select(x => x.Key.ToString()).ToList(); var limit = KeyedBuckets.Sum(x => x.DocCount).Value; if (traceIds.Count == 0) { return(new Trace[0]); } var spanResult = await _elasticClient.SearchAsync <Span>(s => s.Index(index).Size((int)limit).Query(q => q.ConstantScore(c => c.Filter(filter => filter.Terms(t => t.Field(f => f.TraceId).Terms(traceIds)))))); return(spanResult.Documents.GroupBy(x => x.TraceId).Select(x => new Trace { TraceId = x.Key, Spans = x.ToList() }).OrderByDescending(x => x.Spans.Min(s => s.StartTimestamp)).ToList()); }
/// <summary> /// Determines whether the player is balancing on an edge. /// </summary> /// <param name="trA">The result of sensor A.</param> /// <param name="trB">The result of sensor B.</param> private void DetectBalancing(TraceResult trA, TraceResult trB) { if (trA.Hit == trB.Hit) { return; } var flipped = _player.FlipHorizontally; var position = _player.Position; var size = _player.Size; TraceResult tr = trA.Hit ? trA : trB; var reversed = (trA.Hit && flipped) || (trB.Hit && !flipped); double edgeDiff; double objectWidth; if (tr.Entity == null) { var tile = tr.Tile; objectWidth = tile.Definition.Rect.Size.X; edgeDiff = Math.Abs(position.X - (tile.WorldPosition.X + objectWidth / 2.0)); } else { var entity = tr.Entity; objectWidth = entity.Size.X; edgeDiff = Math.Abs(position.X - entity.Position.X); } var tq = new TraceQuery { Line = new Line(position, new Point(position.X, position.Y + (size.Y / 2.0))), CollisionPath = _player.CollisionPath, Ignore = _player, Options = TraceLineOptions.SolidOnly }; var trMiddle = _collisionService.TraceLine(tq); if (!trMiddle.Hit) { if (reversed && (edgeDiff > objectWidth / 2)) { _balanceState = BalanceState.Backward; } else if (edgeDiff > (objectWidth / 2) + 6) { _balanceState = BalanceState.ForwardVeryEdge; } else if (edgeDiff > objectWidth / 2) { _balanceState = BalanceState.Forward; } } }
public bool Trace() { bool result = default; for (int i = 0; i < traceQueries.Length; i++) { TraceQuery query = traceQueries[i]; result ^= CurrentPair.scene.Trace(ref query); } return(result); }
public BenchmarkBVH() { Scene scene = new Scene(); Mesh mesh = new(@"C:\Users\MMXXXVIII\Things\CodingStuff\C#\EchoRenderer\EchoRenderer\Assets\Models\BlenderBMW\BlenderBMW.obj"); scene.children.Add(new MeshObject(mesh, new Matte())); traceQueries = new TraceQuery[65536]; occludeQueries = new OccludeQuery[65536]; IRandom random = new SystemRandom(42); const float Radius = 9f; const float Height = 5f; for (int i = 0; i < traceQueries.Length; i++) { Float2 point = new Float2(MathF.Sqrt(random.Next1()) * Radius, random.Next1() * Height); Float3 position = point.X_Y.RotateXZ(random.Next1() * 360f); Float3 target = Float3.CreateY(0.6f) + random.NextInSphere(0.25f); if (random.Next1() < 0.01f) { Float3 offset = (target - position) / 2f; target = position; position += offset; } Ray ray = new Ray(position, (target - position).Normalized); traceQueries[i] = ray; occludeQueries[i] = ray; } Pairs = new[] { new Pair(new PreparedScene(scene, new ScenePrepareProfile { AggregatorProfile = new AggregatorProfile { AggregatorType = typeof(BoundingVolumeHierarchy) } }), "Regular"), new Pair(new PreparedScene(scene, new ScenePrepareProfile { AggregatorProfile = new AggregatorProfile { AggregatorType = typeof(QuadBoundingVolumeHierarchy) } }), "Quad") }; }
public Task <PageResult <Trace> > GetTraces(TraceQuery traceQuery) { var query = _dbContext.Spans.AsNoTracking().Include(x => x.Tags).AsQueryable(); if (traceQuery.ApplicationName != null) { var traceIds = query.Where(x => x.Tags.Any(t => t.Key == "application" && t.Value == traceQuery.ApplicationName)).Select(x => x.TraceId).ToList(); query = query.Where(x => traceIds.Contains(x.TraceId)); } if (traceQuery.StartTimestamp != null) { query = query.Where(x => x.StartTimestamp <= traceQuery.StartTimestamp); } if (traceQuery.FinishTimestamp != null) { query = query.Where(x => x.FinishTimestamp >= traceQuery.FinishTimestamp); } if (traceQuery.MinDuration != null) { query = query.Where(x => x.Duration >= traceQuery.MinDuration); } if (traceQuery.MaxDuration != null) { query = query.Where(x => x.Duration <= traceQuery.MaxDuration); } var queryGroup = query.GroupBy(x => x.TraceId); var totalMemberCount = queryGroup.Count(); queryGroup = queryGroup.Skip((traceQuery.CurrentPageNumber - 1) * traceQuery.PageSize).Take(traceQuery.PageSize); return(Task.FromResult(new PageResult <Trace>() { CurrentPageNumber = traceQuery.CurrentPageNumber, PageSize = traceQuery.PageSize, TotalMemberCount = totalMemberCount, TotalPageCount = (int)Math.Ceiling((double)totalMemberCount / (double)traceQuery.PageSize), Data = queryGroup.ToList().Select(x => new Trace() { TraceId = x.Key, Spans = _mapper.Map <List <Span> >(x.ToList()) }).ToList() })); }
/// <summary> /// Gets a trace query for use in collision traces during movement. /// </summary> /// <param name="line">The line to use for the trace..</param> /// <returns>A trace query.</returns> private TraceQuery GetTraceQuery(Line line) { var tq = new TraceQuery() { Line = line, Ignore = _parent, CollisionPath = _parent.CollisionPath, Options = TraceLineOptions.SolidOnly }; if (TerrainOnly) { tq.Options |= TraceLineOptions.IgnoreEntities; } return(tq); }
/// <summary> /// Checks whether the player is touching/pushing a wall to the right. /// </summary> /// <param name="touching">set to <c>true</c> if the player is contacting the wall.</param> /// <param name="pushing">set to <c>true</c> is the player is actively pushing agsint the wall.</param> private void CheckWallRight(out bool touching, out bool pushing) { var size = _player.Size; const int maxResolveIterations = 10; touching = false; pushing = false; var halfWidth = size.X / 2.0; double oldX; // don't perform iterative resolution if the player is falling int iterations = _falling ? 0 : maxResolveIterations; do { var position = _player.Position; oldX = position.X; var start = new Point(position.X, position.Y + 4.0); var end = new Point(position.X + halfWidth, position.Y + 4.0); var tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Options = TraceLineOptions.IgnoreJumpThrough | TraceLineOptions.SolidOnly, Ignore = _player }; var tr = _collisionService.TraceLine(tq); if (tr.Hit) { touching = true; if (position.X >= (tr.ContactPoint.X - halfWidth)) { _player.Position = new Point(tr.ContactPoint.X - halfWidth, position.Y); if (_xsp > 0.0) { pushing = true; } } } }while (--iterations > 0 && (oldX != _player.Position.X)); }
/// <summary> /// Determines whether the given point is within the bounding box of an entity. /// </summary> /// <param name="x">The x coordinate.</param> /// <param name="y">The y coordinate.</param> /// <param name="trace">The trace.</param> /// <param name="entity">The entity.</param> /// <returns> /// <c>true</c> if [is point in entity] [the specified x]; otherwise, <c>false</c>. /// </returns> private bool IsPointInEntity(List <GameEntity> entityList, int x, int y, TraceQuery trace, out GameEntity entity) { entity = null; for (var i = 0; i < entityList.Count; i++) { var ent = entityList[i]; var rect = ent.WorldRect; if ( (x >= rect.Position.X && x <= rect.Position.X + rect.Size.X) && (y >= rect.Position.Y && y <= rect.Position.Y + rect.Size.Y)) { entity = ent; break; } } return(entity != null); }
public IHttpActionResult GetParsedCDFTraceTemplate(int jobId, [FromBody] TraceQuery param) { string condition = string.Empty; if (param.Condition != null) { IList <string> conditionList = new List <string>(); if (!string.IsNullOrEmpty(param.Condition.Module)) { conditionList.Add(" ModuleName = '" + param.Condition.Module + "'"); } if (!string.IsNullOrEmpty(param.Condition.Src)) { conditionList.Add(" Src = '" + param.Condition.Src + "'"); } if (!string.IsNullOrEmpty(param.Condition.Function)) { conditionList.Add(" FunctionName = '" + param.Condition.Function + "'"); } if (!string.IsNullOrEmpty(param.Condition.Message)) { conditionList.Add(" Message LIKE '%" + param.Condition.Message + "%'"); } if (conditionList.Count > 0) { condition = string.Format("WHERE {0}", string.Join(" AND ", conditionList)); } } string sql = @"SELECT [ID],[CPU],[LogTime],[ThreadID],[ThreadName],[ProcessID], [ProcessName],[SessionID],[ModuleName] ,[Src],[LineNum],[FunctionName], [LevelID],[ClassName],[Message],[Comments],[RawTraceID],[NodeID], [CdfModuleID],[IsIssuePattern],[JobID] FROM (SELECT ROW_NUMBER() OVER ( ORDER BY LogTime ) AS RowNum, * FROM ParsedCDFTrace_{0} {3}) AS CDFTrace WHERE RowNum >= {1} AND RowNum < {2} ORDER BY RowNum"; List <CDFLine> list = db.Database.SqlQuery <CDFLine>(string.Format(sql, jobId, param.Pagination.startIndex, param.Pagination.endIndex, condition)).ToList <CDFLine>(); return(Ok(list)); }
/// <summary> /// Checks and performs tracking of the prescence of the ground when in floor mode. /// </summary> private void CheckForGroundFloor() { var position = _player.Position; var size = _player.Size; double groundHeight; double halfHeight = (size.Y / 2.0); double footLevel = position.Y + halfHeight; // length of A/B sensors const double sensorLength = 16.0; // A sensor var start = new Point(position.X - 9.0, position.Y); var end = new Point(position.X - 9.0, footLevel + sensorLength); var tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Ignore = _player, Options = TraceLineOptions.SolidOnly }; var trA = _collisionService.TraceLine(tq); groundHeight = trA.Hit ? trA.ContactPoint.Y : Double.MaxValue; // B sensor start = new Point(position.X + 9.0, position.Y); end = new Point(position.X + 9.0, footLevel + sensorLength); tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Ignore = _player, Options = TraceLineOptions.SolidOnly }; var trB = _collisionService.TraceLine(tq); groundHeight = Math.Min(groundHeight, trB.Hit ? trB.ContactPoint.Y : Double.MaxValue); if (!trA.Hit && !trB.Hit) { Fall(); return; } _player.Position = new Point(position.X, groundHeight - halfHeight); CalculateGroundAngle(trA, trB, PlayerMovementMode.Floor); DetectBalancing(trA, trB); }
public async Task <PageViewModel <TraceViewModel> > Get( [FromQuery] string application, [FromQuery] DateTimeOffset?startTimestamp, [FromQuery] DateTimeOffset?finishTimestamp, [FromQuery] int?minDuration, [FromQuery] int?maxDuration, [FromQuery] int?pageNumber, [FromQuery] int?pageSize) { var query = new TraceQuery { ApplicationName = application, StartTimestamp = startTimestamp, FinishTimestamp = finishTimestamp, MinDuration = minDuration, MaxDuration = maxDuration, CurrentPageNumber = pageNumber.GetValueOrDefault(1), PageSize = pageSize.GetValueOrDefault(10) }; var data = await _spanQuery.GetTraces(query); return(_mapper.Map <PageViewModel <TraceViewModel> >(data)); }
public async Task <IEnumerable <TraceHistogramViewModel> > GetTraceHistogram( [FromQuery] string service, [FromQuery] string tags, [FromQuery] long?startTimestamp, [FromQuery] long?finishTimestamp, [FromQuery] int?minDuration, [FromQuery] int?maxDuration, [FromQuery] int?limit) { var query = new TraceQuery { Tags = tags, ServiceName = service, StartTimestamp = TimestampHelpers.Convert(startTimestamp), FinishTimestamp = TimestampHelpers.Convert(finishTimestamp), MinDuration = minDuration, MaxDuration = maxDuration, Limit = limit.GetValueOrDefault(10) }; var data = await _spanQuery.GetTraceHistogram(query); return(_mapper.Map <List <TraceHistogramViewModel> >(data)); }
/// <summary> /// Checks and performs tracking of the prescence of the ground when in left wall mode. /// </summary> private void CheckForGroundLeft() { var position = _player.Position; var size = _player.Size; double groundHeight; double halfHeight = (size.Y / 2.0); double footLevel = position.X - halfHeight; // length of A/B sensors const double sensorLength = 16.0; // A sensor var start = new Point(position.X, position.Y - 9.0); var end = new Point(footLevel - sensorLength, position.Y - 9.0); var tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Ignore = _player, Options = TraceLineOptions.SolidOnly }; var trA = _collisionService.TraceLine(tq); groundHeight = trA.Hit ? trA.ContactPoint.X : footLevel; // B sensor start = new Point(position.X, position.Y + 9.0); end = new Point(footLevel - sensorLength, position.Y + 9.0); tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Ignore = _player, Options = TraceLineOptions.SolidOnly }; var trB = _collisionService.TraceLine(tq); groundHeight = Math.Max(groundHeight, trB.Hit ? trB.ContactPoint.X : footLevel); if (!trA.Hit && !trB.Hit) { Fall(); return; } _player.Position = new Point(groundHeight + halfHeight, position.Y); CalculateGroundAngle(trA, trB, PlayerMovementMode.LeftWall); }
public async Task <IEnumerable <Trace> > GetTraces(TraceQuery traceQuery) { var index = Indices.Index(_indexManager.CreateTracingIndex()); var query = BuildTracesQuery(traceQuery); var traceIdsAggregationsResult = await _elasticClient.SearchAsync <Span>(s => s.Index(index).Size(0).Query(query). Aggregations(a => a.Terms("group_by_traceId", t => t.Aggregations(sub => sub.Min("min_startTimestapm", m => m.Field(f => f.StartTimestamp))).Field(f => f.TraceId).Order(o => o.Descending("min_startTimestapm")).Size(traceQuery.Limit)))); var traceIdsAggregations = traceIdsAggregationsResult.Aggregations.FirstOrDefault().Value as BucketAggregate; if (traceIdsAggregations == null) { return(new Trace[0]); } var traces = traceIdsAggregations.Items.OfType <KeyedBucket <object> >().AsParallel().Select(x => GetTrace(x.Key?.ToString(), index)).OrderByDescending(x => x.Spans.Min(s => s.StartTimestamp)).ToList(); return(traces); }
/// <summary> /// Steps the movement of the parent entity by the controller logic. /// </summary> public override void Move() { if (_falling || !FallOnce) { _ysp += Gravity * _varService.DeltaTime; var position = _parent.Position; var size = _parent.CollisionBox.GetSize(); var tq = new TraceQuery() { Line = new Line(position.X, position.Y, position.X, position.Y + size.Y / 2.0), Ignore = _parent, CollisionPath = _parent.CollisionPath, Options = TraceLineOptions.SolidOnly }; if (TerrainOnly) { tq.Options |= TraceLineOptions.IgnoreEntities; } var tr = _collisionService.TraceLine(tq); if (!tr.Hit) { _falling = true; _ysp = Math.Min(_ysp, MaxFallSpeed); } else { _ysp = 0.0; _parent.Position = new Point(position.X, tr.ContactPoint.Y - size.Y / 2.0); _falling = false; } } base.Move(); }
public Task <IEnumerable <Trace> > GetTraces(TraceQuery traceQuery) { var query = _dbContext.Spans.Include(x => x.Tags).OrderByDescending(x => x.StartTimestamp).AsQueryable(); if (traceQuery.StartTimestamp != null) { query = query.Where(x => x.StartTimestamp >= traceQuery.StartTimestamp); } if (traceQuery.FinishTimestamp != null) { query = query.Where(x => x.FinishTimestamp <= traceQuery.FinishTimestamp); } var queryTags = BuildQueryTags(traceQuery).ToList(); if (queryTags.Any()) { var traceIdsQuery = query; foreach (var item in queryTags) { var tag = item; traceIdsQuery = traceIdsQuery.Where(x => x.Tags.Any(t => t.Key == tag.Key && t.Value == tag.Value)); } var traceIds = traceIdsQuery.Select(x => x.TraceId).Distinct().ToList(); query = query.Where(x => traceIds.Contains(x.TraceId)); } var queryGroup = query.ToList().GroupBy(x => x.TraceId).Take(traceQuery.Limit).ToList(); return(Task.FromResult <IEnumerable <Trace> >(queryGroup.Select(x => new Trace() { TraceId = x.Key, Spans = _mapper.Map <List <Span> >(x.ToList()) }).ToList())); }
private IEnumerable <Tag> BuildQueryTags(TraceQuery traceQuery) { if (!string.IsNullOrEmpty(traceQuery.ServiceName)) { yield return(new Tag { Key = QueryConstants.Service, Value = traceQuery.ServiceName }); } if (!string.IsNullOrEmpty(traceQuery.Tags)) { var tags = traceQuery.Tags.Split('|'); foreach (var tag in tags) { var pair = tag.Split('='); if (pair.Length == 2) { yield return(new Tag { Key = pair[0], Value = pair[1] }); } } } }
public async Task <IEnumerable <TraceHistogram> > GetTraceHistogram(TraceQuery traceQuery) { traceQuery.Ensure(); var query = _dbContext.Spans.AsQueryable(); if (traceQuery.StartTimestamp != null) { query = query.Where(x => x.StartTimestamp >= traceQuery.StartTimestamp); } if (traceQuery.FinishTimestamp != null) { query = query.Where(x => x.FinishTimestamp <= traceQuery.FinishTimestamp); } var queryGroup = query.ToList().GroupBy(x => x.TraceId).ToList(); var histogram = queryGroup.GroupBy(x => x.Min(s => s.StartTimestamp).ToString("yyyy-MM-dd HH:mm")).Select(x => new TraceHistogram { Count = x.Count(), Time = DateTimeOffset.Parse(x.Key) }); return(histogram.ToList()); }
public Task <IEnumerable <TraceOperationHistogram> > GetSpanHistogramByOperaionName(TraceQuery traceQuery) { throw new NotImplementedException(); }
public async Task <IEnumerable <Trace> > GetTraces(TraceQuery traceQuery) { var sql = "SELECT TOP (@Limit) TraceId, MIN(StartTimestamp) as StartTimestamp, MIN(FinishTimestamp) as FinishTimestamp from Spans"; if (traceQuery.StartTimestamp.HasValue || traceQuery.FinishTimestamp.HasValue) { sql += " WHERE"; } if (traceQuery.StartTimestamp.HasValue) { sql += " StartTimestamp > @StartTimestamp"; } if (traceQuery.StartTimestamp.HasValue && traceQuery.FinishTimestamp.HasValue) { sql += " AND"; } if (traceQuery.FinishTimestamp.HasValue) { sql += " FinishTimestamp < @FinishTimestamp"; } if ((traceQuery.StartTimestamp.HasValue || traceQuery.FinishTimestamp.HasValue) && !string.IsNullOrEmpty(traceQuery.ServiceName)) { sql += " AND"; } //TODO: Figure out how to filter on tags... //var tags = BuildQueryTags(traceQuery); if (!string.IsNullOrEmpty(traceQuery.ServiceName)) { sql += " TraceId IN (SELECT s.traceid FROM Spans s JOIN Tags t ON s.SpanId = t.SpanId WHERE t.[Key] = 'service.name' AND t.Value = @ServiceName)"; } sql += " GROUP BY TraceId" + " ORDER BY starttimestamp DESC"; var traces = new List <Trace>(); using (var conn = await GetConnectionAsync()) using (var cmd = new SqlCommand(sql, conn)) { cmd.Parameters.AddWithValue("Limit", traceQuery.Limit); if (traceQuery.StartTimestamp.HasValue) { cmd.Parameters.AddWithValue("StartTimestamp", traceQuery.StartTimestamp.Value); } if (traceQuery.FinishTimestamp.HasValue) { cmd.Parameters.AddWithValue("FinishTimestamp", traceQuery.FinishTimestamp.Value); } if (!string.IsNullOrEmpty(traceQuery.ServiceName)) { cmd.Parameters.AddWithValue("ServiceName", traceQuery.ServiceName); } using (var reader = await cmd.ExecuteReaderAsync()) { while (await reader.ReadAsync()) { var traceId = reader.GetString(0); var trace = await GetTrace(traceId); traces.Add(trace); } } return(traces); } }
/// <summary> /// Checks for the floor or ceiling whilst in the air. /// </summary> private void CheckForGroundInAir() { if (!_falling) { return; } var position = _player.Position; var size = _player.Size; double ceilingHeight, groundHeight; double halfHeight = (size.Y / 2.0); double footHeight = position.Y + halfHeight; // length of C/D sensors const double sensorLength = 16.0; // A sensor var start = new Point(position.X - 7.0, position.Y); var end = new Point(position.X - 7.0, footHeight + sensorLength); var tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Ignore = _player, Options = TraceLineOptions.SolidOnly }; var trA = _collisionService.TraceLine(tq); groundHeight = trA.Hit ? trA.ContactPoint.Y : Double.MaxValue; // B sensor start = new Point(position.X + 7.0, position.Y); end = new Point(position.X + 7.0, footHeight + sensorLength); tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Ignore = _player, Options = TraceLineOptions.SolidOnly }; var trB = _collisionService.TraceLine(tq); groundHeight = Math.Min(groundHeight, trB.Hit ? trB.ContactPoint.Y : Double.MaxValue); if (trA.Hit || trB.Hit) { if (_ysp > 0.0) { if (groundHeight - position.Y < halfHeight) { // reaquired the ground // get the ground angle CalculateGroundAngle(trA, trB, PlayerMovementMode.Floor); SetMovementMode(); _falling = false; _jumping = false; if ((_controlState & ControllerState.Down) == ControllerState.None) { Unroll(); } else if ((_groundAngle != 0.0) || (Math.Abs(_xsp) > 1.03125)) { if (RollSound != 0) { _audioService.PlaySoundEffect(RollSound); } } CalculateLandingSpeed(); } } } // C sensor start = new Point(position.X - 7.0, position.Y); end = new Point(position.X - 7.0, position.Y - halfHeight - sensorLength); tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Options = TraceLineOptions.IgnoreJumpThrough | TraceLineOptions.SolidOnly, Ignore = _player }; var trC = _collisionService.TraceLine(tq); ceilingHeight = trC.ContactPoint.Y; // D sensor start = new Point(position.X + 7.0, position.Y); end = new Point(position.X + 7.0, position.Y - halfHeight - sensorLength); tq = new TraceQuery { Line = new Line(start, end), CollisionPath = _player.CollisionPath, Options = TraceLineOptions.IgnoreJumpThrough | TraceLineOptions.SolidOnly, Ignore = _player }; var trD = _collisionService.TraceLine(tq); ceilingHeight = Math.Max(ceilingHeight, trD.ContactPoint.Y); if (trC.Hit || trD.Hit) { if (position.Y - ceilingHeight < halfHeight) { _player.Position = new Point(position.X, ceilingHeight + halfHeight); _ysp = Math.Max(_ysp, 0.0); } } }
private Func <QueryContainerDescriptor <Span>, QueryContainer> BuildTracesQuery(TraceQuery traceQuery) { return(query => query.Bool(b => b.Must(BuildMustQuery(traceQuery)))); }
private IEnumerable <Func <QueryContainerDescriptor <Span>, QueryContainer> > BuildMustQuery(TraceQuery traceQuery) { if (traceQuery.StartTimestamp != null) { yield return(q => q.DateRange(d => d.Field(x => x.StartTimestamp).GreaterThanOrEquals(traceQuery.StartTimestamp.Value.DateTime))); } if (traceQuery.FinishTimestamp != null) { yield return(q => q.DateRange(d => d.Field(x => x.FinishTimestamp).LessThanOrEquals(traceQuery.FinishTimestamp.Value.DateTime))); } foreach (var queryTag in BuildQueryTags(traceQuery)) { yield return(q => q.Nested(n => n.Path(x => x.Tags).Query(q1 => q1.Bool(b => b.Must(f => f.Term(new Field("tags.key"), queryTag.Key?.ToLower()), f => f.Term(new Field("tags.value"), queryTag.Value?.ToLower())))))); } }
/// <summary> /// Performs a jump. /// </summary> private void Jump() { if (_falling) { // cant jump whilst in the air return; } var position = _player.Position; var size = _player.Size; _jumping = true; double deltaX, deltaY; switch (_movementMode) { case PlayerMovementMode.Floor: deltaX = 0.0; deltaY = -((size.Y / 2) + 5.0); break; case PlayerMovementMode.Ceiling: deltaX = 0.0; deltaY = ((size.Y / 2) + 5.0); break; case PlayerMovementMode.RightWall: deltaX = -((size.Y / 2) + 5.0); deltaY = 0.0; break; case PlayerMovementMode.LeftWall: deltaX = ((size.Y / 2) + 5.0); deltaY = 0.0; break; default: deltaX = 0.0; deltaY = 0.0; break; } var tq = new TraceQuery { Line = new Line(position.X, position.Y, position.X + deltaX, position.Y + deltaY), CollisionPath = _player.CollisionPath, Options = TraceLineOptions.IgnoreJumpThrough | TraceLineOptions.SolidOnly, Ignore = _player }; var tr = _collisionService.TraceLine(tq); if (tr.Hit) { // relative ceiling too low, nowhere to jump return; } _movementMode = PlayerMovementMode.Floor; _falling = true; _rolling = true; _player.SetBoundingBox(Player.RollingBox); var rad = _groundAngle * (Math.PI / 180.0); _xsp -= JumpSpeed * -Math.Sin(rad); _ysp -= JumpSpeed * -Math.Cos(rad); if (_ysp < JumpSpeed) { _ysp = JumpSpeed; } if (JumpSound != 0) { _audioService.PlaySoundEffect(JumpSound); } }