예제 #1
0
        private bool Inspect(SysEventStats stats)
        {
            var playduration     = stats.LastTrigger - stats.FirstTrigger;
            var avgSecPerTrigger = stats.TotalTriggerTime.TotalSeconds / stats.TotalTriggerCount;

            if (avgSecPerTrigger <= 0.2)
            {
                return(true);
            }

            if (stats.TriggerStreak >= 20)
            {
                return(true);
            }

            if (stats.HighestTriggerStreak >= 3)
            {
                //var avgTriggerTimes = stats.GetAverageTriggerTimes();
                if (avgSecPerTrigger <= 0.45 && stats.TriggerStreak == stats.HighestTriggerStreak)
                {
                    return(true);
                }
                if (avgSecPerTrigger <= 0.6 && stats.TriggerStreak >= 12 && stats.TriggerStreak == stats.HighestTriggerStreak)
                {
                    return(true);
                }
                if (avgSecPerTrigger <= 0.7 && stats.TriggerStreak >= 16 && stats.TriggerStreak == stats.HighestTriggerStreak)
                {
                    return(true);
                }

                var streakDuration = stats.LastTrigger - stats.TriggerStreakStart;
                if (avgSecPerTrigger <= 3.0 && stats.TriggerStreak >= 24 && streakDuration >= TimeSpan.FromHours(8))
                {
                    return(true);
                }
                if (avgSecPerTrigger <= 2.0 && stats.TriggerStreak >= 12 && streakDuration >= TimeSpan.FromHours(4))
                {
                    return(true);
                }
                if (avgSecPerTrigger <= 1.0 && stats.TriggerStreak >= 06 && streakDuration >= TimeSpan.FromHours(2))
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #2
0
        private void Process(object obj)
        {
            while (!disposed)
            {
                var newTriggers = false;
                lock (triggerMutex)
                {
                    while (activeInputs.TryDequeue(out var input))
                    {
                        var alreadyTriggered = false;
                        var triggered        = false;
                        foreach (var activeEvent in activeEvents)
                        {
                            if (!activeEvent.Triggered.Add(input.Source))
                            {
                                alreadyTriggered = true;
                                continue;
                            }
                            if (!activeEvent.IsAlive)
                            {
                                continue;
                            }

                            if (activeEvent.Created > input.Sent)
                            {
                                continue; // input has to be after event
                            }
                            if (CheckTrigger(activeEvent, input))
                            {
                                var triggerDelay = input.Sent - activeEvent.Created;
                                newTriggers = true;
                                triggered   = true;
                                if (!sourceStatistics.TryGetValue(input.Source, out var stats))
                                {
                                    sourceStatistics[input.Source] = stats = new SysEventStats(input.Source);
                                }
                                stats.TriggerCount.TryGetValue(input.Input, out var tc);
                                stats.TriggerCount[input.Input] = tc + 1;
                                stats.InputCount.TryGetValue(input.Input, out var ic);
                                stats.InputCount[input.Input] = ic + 1;
                                ++stats.TriggerStreak;
                                stats.HighestTriggerStreak = Math.Max(stats.TriggerStreak, stats.HighestTriggerStreak);
                                if (stats.FirstTrigger == DateTime.MinValue)
                                {
                                    stats.FirstTrigger = DateTime.UtcNow;
                                }
                                if (stats.TriggerStreakStart == DateTime.MinValue)
                                {
                                    stats.TriggerStreakStart = DateTime.UtcNow;
                                }
                                stats.TriggerTime.TryGetValue(input.Input, out var tt);
                                stats.TriggerTime[input.Input] = tt + triggerDelay;
                                stats.TotalTriggerTime        += triggerDelay;
                                stats.LastTriggerDelay         = triggerDelay;
                                stats.LastTrigger = DateTime.UtcNow;
                                stats.TriggerRangeMin.TryGetValue(input.Input, out var trmin);
                                stats.TriggerRangeMin[input.Input] = trmin > 0 ? Math.Min(trmin, triggerDelay.TotalSeconds) : triggerDelay.TotalSeconds;
                                stats.TriggerRangeMax.TryGetValue(input.Input, out var trmax);
                                stats.TriggerRangeMax[input.Input] = Math.Max(trmax, triggerDelay.TotalSeconds);
                            }
                        }

                        if (!triggered)
                        {
                            if (!sourceStatistics.TryGetValue(input.Source, out var stats))
                            {
                                sourceStatistics[input.Source] = stats = new SysEventStats(input.Source);
                            }
                            stats.InputCount.TryGetValue(input.Input, out var count);
                            stats.InputCount[input.Input] = count + 1;
                        }

                        var triggerStreak = false;
                        foreach (var deadEvent in activeEvents.Where(x => !x.IsAlive))
                        {
                            triggerStreak = triggerStreak || CheckTrigger(deadEvent, input);
                        }

                        if (!triggerStreak && !triggered && !alreadyTriggered)
                        {
                            if (!sourceStatistics.TryGetValue(input.Source, out var stats))
                            {
                                sourceStatistics[input.Source] = stats = new SysEventStats(input.Source);
                            }
                            stats.HighestTriggerStreak = Math.Max(stats.TriggerStreak, stats.HighestTriggerStreak);
                            stats.TriggerStreakBreak   = DateTime.UtcNow;
                            ++stats.TriggerStreakBreakCount;
                            stats.TriggerStreak      = 0;
                            stats.TriggerStreakStart = DateTime.MinValue;
                        }
                    }
                    activeEvents.RemoveAll(x => !x.IsAlive);
                }

                if (newTriggers)
                {
                    ReinvalidateAndInspectSuspects();
                }

                System.Threading.Thread.Sleep(10);
            }
        }