Example #1
0
        private void TelemetryStateUpdater(TelemetryState obj)
        {
            MethodInvoker dele = delegate()
            {
                pfd1.YawAngle      = obj.Yaw;
                pfd1.RollAngle     = obj.Roll;
                pfd1.PitchAngle    = obj.Pitch;
                pfd1.Altitude      = obj.Height;
                pfd1.AirSpeed      = 100.0f * (float)Math.Sqrt(obj.SpeedY * obj.SpeedY + obj.SpeedX * obj.SpeedX + obj.SpeedZ * obj.SpeedZ);
                pfd1.VerticalSpeed = obj.SpeedZ * 100.0f;
                pfd1.Invalidate();
                lbBar.Text        = obj.Barometer.ToString();
                gBattery.Value    = obj.Battery;
                gTemp.Value       = obj.Temperature;
                gSpeedX.Value     = 100.0f * obj.SpeedX;
                gSpeedY.Value     = 100.0f * obj.SpeedY;
                gSpeedZ.Value     = 100.0f * obj.SpeedZ;
                gAccelX.Value     = obj.AccelX;
                gAccelY.Value     = obj.AccelY;
                gAccelZ.Value     = obj.AccelZ;
                lblTime.Text      = obj.FlyTime.ToString();
                lblTof.Text       = obj.TOF.ToString();
                lblBatLow.Visible = obj.Battery <= 20;
            };

            Invoke(dele);
        }
Example #2
0
        /// <summary>
        /// Post-Request processing
        /// </summary>
        /// <param name="context">type: IOwinContext</param>
        private void EndRequest(IOwinContext context)
        {
            if (HttpContext.Current == null)
            {
                return;
            }

            var startTime = ItemDecorator.GetInspectorInstance()[ItemDecorator.RequestStartTime];

            if (startTime != null
                //// ignore non-user pings
                && TelemetryState.IsTelemetryEnabledUserAgent()
                //// ignore requests to specific paths
                && TelemetryState.IsTelemetryEnabledRequestPath()
                //// ignore requests to specific extensions
                && TelemetryState.IsTelemetryEnabledRequestExtension()
                //// make sure the portal is configured
                && this.IsPortalConfigured())
            {
                var requestStartTime = (DateTime)startTime;
                var elapsedTime      = DateTime.UtcNow - requestStartTime;
                MdmMetrics.RequestExecutionTimeMetric.LogValue((long)elapsedTime.TotalMilliseconds);

                var ag = PerformanceAggregateLogger.GetPerformanceAggregate();
                if (ag != null)
                {
                    PerformanceEventSource.Log.PerformanceAggregate(ag, elapsedTime);
                }
            }
        }
Example #3
0
        /// <inheritdoc />
        public void InitializeTargetFrameworkRules(ImmutableArray <ITargetFramework> targetFrameworks, IReadOnlyCollection <string> rules)
        {
            if (_stateByFramework == null)
            {
                return;
            }

            lock (_stateUpdateLock)
            {
                if (_stateByFramework == null)
                {
                    return;
                }

                foreach (ITargetFramework targetFramework in targetFrameworks)
                {
                    if (!_stateByFramework.TryGetValue(targetFramework, out TelemetryState telemetryState))
                    {
                        telemetryState = _stateByFramework[targetFramework] = new TelemetryState();
                    }

                    foreach (string rule in rules)
                    {
                        telemetryState.InitializeRule(rule);
                    }
                }
            }
        }
Example #4
0
        public static TelemetryState ToTelemetryState(this Sim instance, DGConfig config, TelemetryState oldState)
        {
            var tState = new TelemetryState()
            {
                IsConnected          = instance.Sdk.IsConnected,
                IsRunning            = instance.Sdk.IsRunning,
                DriverMarker         = instance.Sdk.GetTelemetryValue <bool>("DriverMarker").Value,
                OnPitRoad            = instance.Sdk.GetTelemetryValue <bool>("OnPitRoad").Value,
                PlayerCarTowTime     = instance.Sdk.GetTelemetryValue <float>("PlayerCarTowTime").Value,
                PlayerCarInPitStall  = instance.Sdk.GetTelemetryValue <bool>("PlayerCarInPitStall").Value,
                LapsCompleted        = instance.Sdk.GetTelemetryValue <int>("LapCompleted").Value,
                CurrentDriver        = instance.Driver?.Name,
                TeamName             = instance.Driver?.TeamName,
                CurrentSessionNumber = instance.CurrentSessionNumber,
                SubsessionId         = instance.SessionData.SubsessionId
            };

            tState.UpdateEvent = GetUpdateType(tState, oldState);

            foreach (KeyValuePair <string, ConfFormField> field in config.FormMapping)
            {
                object value;

                switch (field.Key)
                {
                case "UpdateEvent":
                    value = tState.UpdateEvent;
                    break;

                case "CurrentDriver":
                    value = instance.Driver?.Name;
                    break;

                case "TeamName":
                    value = instance.Driver?.TeamName;
                    break;

                case "CurrentSessionNumber":
                    value = instance.CurrentSessionNumber;
                    break;

                case "SubsessionId":
                    value = instance.SessionData.SubsessionId;
                    break;

                default:
                    value = instance.Sdk.GetTelemetryValue <object>(field.Key)?.Value;
                    break;
                }
                tState.Fields.Add(field.Key, new TelemetryFormField()
                {
                    Name   = field.Key,
                    FormId = field.Value.FormId,
                    SendOn = field.Value.SendOn,
                    Value  = value
                });
            }

            return(tState);
        }
Example #5
0
        public IRacingMonitor(DGConfig config)
        {
            this.config = config;

            Sim.Instance.TelemetryUpdated += TelemetryUpdate;

            this.httpClient = new HttpClient();
            this.state      = new TelemetryState();
        }
Example #6
0
        private async Task <SearchResult <IPackageSearchMetadata> > AggregateSearchResultsAsync(
            string searchText,
            IEnumerable <SearchResult <IPackageSearchMetadata> > results,
            TelemetryState telemetryState)
        {
            SearchResult <IPackageSearchMetadata> result;

            var nonEmptyResults = results.Where(r => r.Any()).ToArray();

            if (nonEmptyResults.Length == 0)
            {
                result = SearchResult.Empty <IPackageSearchMetadata>();
            }
            else if (nonEmptyResults.Length == 1)
            {
                result = SearchResult.FromItems(nonEmptyResults[0].Items);
            }
            else
            {
                var items = nonEmptyResults.Select(r => r.Items).ToArray();

                var indexer         = new RelevanceSearchResultsIndexer();
                var aggregator      = new SearchResultsAggregator(indexer, new PackageSearchMetadataSplicer());
                var aggregatedItems = await aggregator.AggregateAsync(
                    searchText, items);

                result = SearchResult.FromItems(aggregatedItems.ToArray());
                // set correct count of unmerged items
                result.RawItemsCount = items.Aggregate(0, (r, next) => r + next.Count);
            }

            result.SourceSearchStatus = results
                                        .SelectMany(r => r.SourceSearchStatus)
                                        .ToDictionary(kv => kv.Key, kv => kv.Value);

            var cursors = results
                          .Where(r => r.NextToken != null)
                          .ToDictionary(r => r.SourceSearchStatus.Single().Key, r => r.NextToken);

            if (cursors.Keys.Any())
            {
                result.NextToken = new AggregatedContinuationToken
                {
                    TelemetryState      = telemetryState,
                    SearchString        = searchText,
                    SourceSearchCursors = cursors
                };
            }

            return(result);
        }
        protected void Session_Start(object sender, EventArgs e)
        {
            Session["init"] = 0;

            if (FeatureCheckHelper.IsFeatureEnabled(FeatureNames.TelemetryFeatureUsage)
                // ignore non-user pings
                && TelemetryState.IsTelemetryEnabledUserAgent()
                // ignore requests to and referred requests from specific paths
                && TelemetryState.IsTelemetryEnabledRequestPage()
                // only report this telemetry when the portal is configured
                && SetupConfig.IsPortalConfigured())
            {
                PortalFeatureTrace.TraceInstance.LogSessionInfo(FeatureTraceCategory.SessionStart);
            }
        }
Example #8
0
        public override bool Equals(object obj)
        {
            bool result = false;

            if (obj is ConsoleState)
            {
                ConsoleState other = (ConsoleState)obj;
                result = Id.Equals(other.Id) &&
                         Connected.Equals(other.Connected) &&
                         TelemetryState.Equals(other.TelemetryState) &&
                         TelemetryInterval.Equals(other.TelemetryInterval) &&
                         ConsoleColor.Equals(other.ConsoleColor);
            }
            return(result);
        }
        /// <summary>
        /// Initialize telemetry state with the set of rules we expect to observe for target framework
        /// </summary>
        public void InitializeTargetFrameworkRules(ITargetFramework targetFramework, IEnumerable <string> rules)
        {
            lock (_stateUpdateLock)
            {
                if (_stopTelemetry)
                {
                    return;
                }

                TelemetryState telemetryState = _telemetryStates.GetOrAdd(targetFramework, (key) => new TelemetryState());

                foreach (string rule in rules)
                {
                    telemetryState.InitializeRule(rule);
                }
            }
        }
Example #10
0
        private static UpdateEvents GetUpdateType(TelemetryState newState, TelemetryState oldState)
        {
            // Tow start
            if (oldState.PlayerCarTowTime == 0 && newState.PlayerCarTowTime > 0)
            {
                return(UpdateEvents.TowStart);
            }

            // New Lap
            if (oldState.LapsCompleted < newState.LapsCompleted)
            {
                return(UpdateEvents.LapStart);
            }

            // Pit road entry
            if (!oldState.OnPitRoad && newState.OnPitRoad)
            {
                return(UpdateEvents.PitRdEntry);
            }

            // Pit Stop Start
            if (!oldState.PlayerCarInPitStall && newState.PlayerCarInPitStall)
            {
                return(UpdateEvents.PitStart);
            }

            // Pit stop end
            if (oldState.PlayerCarInPitStall && !newState.PlayerCarInPitStall)
            {
                return(UpdateEvents.PitFinish);
            }

            // Pit road exit
            if (oldState.OnPitRoad && !newState.OnPitRoad)
            {
                return(UpdateEvents.PitRdExit);
            }

            return(UpdateEvents.None);
        }
Example #11
0
        private async void TelemetryUpdate(object sender, SdkWrapper.TelemetryUpdatedEventArgs e)
        {
            List <long> myTimes = new List <long>();

            var newState = Sim.Instance.ToTelemetryState(this.config, this.state);

            if (!String.IsNullOrWhiteSpace(this.config.FormUrl))
            {
                if (newState.UpdateEvent != UpdateEvents.None)
                {
                    var req = new HttpRequestMessage(HttpMethod.Post, this.config.FormUrl);
                    req.Content = newState.GetForm();
                    await this.httpClient.SendAsync(req);

                    Console.WriteLine("Posted to sheet @ {0}", DateTime.Now);
                }
            }
            this.state = newState;
            if (this.config.PostTelemetryToConsole)
            {
                this.Print(e.TelemetryInfo, string.Join(" | ", myTimes));
            }
        }
Example #12
0
        private async Task <SearchResult <IPackageSearchMetadata> > WaitForCompletionOrBailOutAsync(
            string searchText,
            IDictionary <string, Task <SearchResult <IPackageSearchMetadata> > > searchTasks,
            TelemetryState telemetryState,
            CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            if (searchTasks.Count == 0)
            {
                return(SearchResult.Empty <IPackageSearchMetadata>());
            }

            var aggregatedTask = Task.WhenAll(searchTasks.Values);

            RefreshToken refreshToken = null;

            if (aggregatedTask != await Task.WhenAny(aggregatedTask, Task.Delay(DefaultTimeout)))
            {
                refreshToken = new AggregatedRefreshToken
                {
                    TelemetryState = telemetryState,
                    SearchString   = searchText,
                    SearchTasks    = searchTasks,
                    RetryAfter     = DefaultTimeout
                };
            }

            var partitionedTasks = searchTasks
                                   .ToLookup(t => t.Value.Status == TaskStatus.RanToCompletion);

            var completedOnly = partitionedTasks[true];

            SearchResult <IPackageSearchMetadata> aggregated;
            IEnumerable <TimeSpan> timings = null;
            var timeAggregation            = new Stopwatch();

            if (completedOnly.Any())
            {
                var results = await Task.WhenAll(completedOnly.Select(kv => kv.Value));

                timings = results.Select(e => e.Duration);
                timeAggregation.Start();
                aggregated = await AggregateSearchResultsAsync(searchText, results, telemetryState);

                timeAggregation.Stop();
            }
            else
            {
                timings    = Enumerable.Empty <TimeSpan>();
                aggregated = SearchResult.Empty <IPackageSearchMetadata>();
            }

            aggregated.OperationId  = telemetryState?.OperationId;
            aggregated.RefreshToken = refreshToken;

            var notCompleted = partitionedTasks[false];

            if (notCompleted.Any())
            {
                var statuses = notCompleted.ToDictionary(
                    kv => kv.Key,
                    kv => GetLoadingStatus(kv.Value.Status));

                foreach (var item in statuses)
                {
                    aggregated.SourceSearchStatus.Add(item);
                }

                var exceptions = notCompleted
                                 .Where(kv => kv.Value.Exception != null)
                                 .ToDictionary(
                    kv => kv.Key,
                    kv => (Exception)kv.Value.Exception);

                foreach (var item in exceptions)
                {
                    aggregated.SourceSearchException.Add(item);
                }
            }

            if (_telemetryService != null &&
                aggregated.SourceSearchStatus != null &&
                aggregated.SourceSearchStatus.Values != null &&
                telemetryState != null)
            {
                var loadingStatus = aggregated.SourceSearchStatus.Values.Aggregate();
                if (loadingStatus != LoadingStatus.Loading &&
                    telemetryState.ShouldEmit)
                {
                    telemetryState.Duration.Stop();
                    _telemetryService.EmitTelemetryEvent(new SearchPageTelemetryEvent(
                                                             telemetryState.OperationId,
                                                             telemetryState.PageIndex,
                                                             aggregated.Items?.Count ?? 0,
                                                             telemetryState.Duration.Elapsed,
                                                             timings,
                                                             timeAggregation.Elapsed,
                                                             loadingStatus));
                }
            }

            return(aggregated);
        }
Example #13
0
        private TelemetryState ParseState(string[] pairs)
        {
            var state = new TelemetryState();
            // pitch:-1;roll:0;yaw:-92;vgx:0;vgy:0;vgz:0;templ:47;temph:49;tof:10;h:0;bat:9;baro:93.10;time:0;agx:-23.00;agy:-8.00;agz:-995.00;
            float?temp = null;
            int   some;

            foreach (var pair in pairs)
            {
                var tokens = pair.Split(':');
                switch (tokens[0])
                {
                case "pitch":
                    state.Pitch = DegreeToValue(int.Parse(tokens[1]));
                    break;

                case "roll":
                    state.Roll = DegreeToValue(int.Parse(tokens[1]));
                    break;

                case "yaw":
                    state.Yaw = DegreeToValue(int.Parse(tokens[1]));
                    break;

                case "vgx":
                    state.SpeedX = int.Parse(tokens[1]) / 100.0f;
                    break;

                case "vgy":
                    state.SpeedY = int.Parse(tokens[1]) / 100.0f;
                    break;

                case "vgz":
                    state.SpeedZ = int.Parse(tokens[1]) / 100.0f;
                    break;

                case "templ":
                    some = int.Parse(tokens[1]);
                    if (temp == null)
                    {
                        temp = some;
                    }
                    else
                    {
                        temp = (temp.Value + some) / 2.0f;
                    }
                    break;

                case "temph":
                    some = int.Parse(tokens[1]);
                    if (temp == null)
                    {
                        temp = some;
                    }
                    else
                    {
                        temp = (temp.Value + some) / 2.0f;
                    }
                    break;

                case "tof":
                    state.TOF = int.Parse(tokens[1]) / 100.0f;
                    break;

                case "h":
                    state.Height = int.Parse(tokens[1]) / 100.0f;
                    break;

                case "bat":
                    state.Battery = int.Parse(tokens[1]);
                    break;

                case "baro":
                    state.Barometer = float.Parse(tokens[1]);
                    break;

                case "time":
                    state.FlyTime = int.Parse(tokens[1]);
                    break;

                case "agx":
                    state.AccelX = float.Parse(tokens[1]) / 100.0f;
                    break;

                case "agy":
                    state.AccelY = float.Parse(tokens[1]) / 100.0f;
                    break;

                case "agz":
                    state.AccelZ = float.Parse(tokens[1]) / 100.0f;
                    break;

                default:
                    break;
                }
            }
            state.Temperature = temp.GetValueOrDefault();
            return(state);
        }
Example #14
0
 public override int GetHashCode()
 {
     return(Id.GetHashCode() + Connected.GetHashCode() + TelemetryState.GetHashCode() + TelemetryInterval.GetHashCode() + ConsoleColor.GetHashCode());
 }