예제 #1
0
        // Token: 0x060004AB RID: 1195 RVA: 0x0001B2C4 File Offset: 0x000194C4
        private static GlsProcessPerformanceCountersInstance CreateGlsProcessPerfCountersInstance()
        {
            GlsProcessPerformanceCountersInstance result = null;
            string text = null;

            using (Process currentProcess = Process.GetCurrentProcess())
            {
                text = string.Format("{0} {1}{2}{3}", new object[]
                {
                    currentProcess.ProcessName,
                    Globals.ProcessAppName ?? string.Empty,
                    string.IsNullOrEmpty(Globals.ProcessAppName) ? string.Empty : " ",
                    Globals.ProcessId
                });
            }
            try
            {
                result = GlsProcessPerformanceCounters.GetInstance(text);
            }
            catch (InvalidOperationException arg)
            {
                ExTraceGlobals.PerfCountersTracer.TraceError <string, InvalidOperationException>(0L, "Get GlsProcessPerformanceCountersInstance {0} failed due to: {1}", text, arg);
            }
            return(result);
        }
예제 #2
0
        // Token: 0x060004A4 RID: 1188 RVA: 0x0001AD68 File Offset: 0x00018F68
        private static void UpdatePerMinuteCounters(object state)
        {
            GlsProcessPerformanceCountersInstance value = ADProviderPerf.processGlsCounters.Value;

            if (value != null)
            {
                lock (ADProviderPerf.slidingTotalLockRoot)
                {
                    value.SuccessfulCallsPerMinute.RawValue = ADProviderPerf.successesPerMinute.Sum;
                    value.FailedCallsPerMinute.RawValue     = ADProviderPerf.failuresPerMinute.Sum;
                    value.NotFoundCallsPerMinute.RawValue   = ADProviderPerf.notFoundsPerMinute.Sum;
                    value.CacheHitsRatioPerMinute.RawValue  = (long)ADProviderPerf.cacheHitsPercentageForLastMinute.GetSlidingPercentage();
                    value.AcceptedDomainLookupCacheHitsRatioPerMinute.RawValue            = (long)ADProviderPerf.acceptedDomainLookupCacheHitsPercentageForLastMinute.GetSlidingPercentage();
                    value.ExternalDirectoryOrganizationIdCacheHitsRatioPerMinute.RawValue = (long)ADProviderPerf.externalDirOrgIdCacheHitsPercentageForLastMinute.GetSlidingPercentage();
                    value.MSAUserNetIdCacheHitsRatioPerMinute.RawValue = (long)ADProviderPerf.msaUserNetIdLookupCacheHitsPercentageForLastMinute.GetSlidingPercentage();
                }
            }
            if (ADProviderPerf.directoryCacheHitCounter.IsInitialized && ADProviderPerf.directoryCacheHitCounter.Value != null)
            {
                MSExchangeDirectoryCacheServiceCounters.CacheHit.RawValue = (long)ADProviderPerf.directoryCacheHitCounter.Value.GetSlidingPercentage();
            }
            if (ADProviderPerf.directoryAcceptedDomainCacheHitCounter.IsInitialized && ADProviderPerf.directoryAcceptedDomainCacheHitCounter.Value != null)
            {
                MSExchangeDirectoryCacheServiceCounters.AcceptedDomainHit.RawValue = (long)ADProviderPerf.directoryAcceptedDomainCacheHitCounter.Value.GetSlidingPercentage();
            }
            if (ADProviderPerf.directoryADRawEntryCacheHitCounter.IsInitialized && ADProviderPerf.directoryADRawEntryCacheHitCounter.Value != null)
            {
                MSExchangeDirectoryCacheServiceCounters.ADRawEntryCacheHit.RawValue = (long)ADProviderPerf.directoryADRawEntryCacheHitCounter.Value.GetSlidingPercentage();
            }
            if (ADProviderPerf.directoryADRawEntryPropertiesMisMatchCounter.IsInitialized && ADProviderPerf.directoryADRawEntryPropertiesMisMatchCounter.Value != null)
            {
                MSExchangeDirectoryCacheServiceCounters.ADRawEntryPropertiesMismatchLastMinute.RawValue = (long)ADProviderPerf.directoryADRawEntryPropertiesMisMatchCounter.Value.GetSlidingPercentage();
            }
            if (ADProviderPerf.directoryConfigUnitCacheHitCounter.IsInitialized && ADProviderPerf.directoryConfigUnitCacheHitCounter.Value != null)
            {
                MSExchangeDirectoryCacheServiceCounters.ConfigurationUnitHit.RawValue = (long)ADProviderPerf.directoryConfigUnitCacheHitCounter.Value.GetSlidingPercentage();
            }
            if (ADProviderPerf.directoryRecipientCacheHitCounter.IsInitialized && ADProviderPerf.directoryRecipientCacheHitCounter.Value != null)
            {
                MSExchangeDirectoryCacheServiceCounters.RecipientHit.RawValue = (long)ADProviderPerf.directoryRecipientCacheHitCounter.Value.GetSlidingPercentage();
            }
            if (ADProviderPerf.adDriverCacheHitCounter.IsInitialized && ADProviderPerf.adDriverCacheHitCounter.Value != null)
            {
                MSExchangeADAccessCacheCountersInstance value2 = ADProviderPerf.processADDriverCacheCounters.Value;
                if (value2 != null)
                {
                    value2.CacheHit.RawValue = (long)ADProviderPerf.adDriverCacheHitCounter.Value.GetSlidingPercentage();
                }
            }
        }
예제 #3
0
        // Token: 0x060004A3 RID: 1187 RVA: 0x0001AA18 File Offset: 0x00018C18
        public static void UpdateGlsCallLatency(string apiName, bool isRead, int latencyMsec, bool success)
        {
            GlsProcessPerformanceCountersInstance value = ADProviderPerf.processGlsCounters.Value;

            GlsPerformanceCounters.AverageOverallLatency.IncrementBy((long)latencyMsec);
            GlsPerformanceCounters.AverageOverallLatencyBase.Increment();
            if (isRead)
            {
                GlsPerformanceCounters.AverageReadLatency.IncrementBy((long)latencyMsec);
                GlsPerformanceCounters.AverageReadLatencyBase.Increment();
                if (value != null)
                {
                    value.AverageReadLatency.IncrementBy((long)latencyMsec);
                    value.AverageReadLatencyBase.Increment();
                }
            }
            else
            {
                GlsPerformanceCounters.AverageWriteLatency.IncrementBy((long)latencyMsec);
                GlsPerformanceCounters.AverageWriteLatencyBase.Increment();
                if (value != null)
                {
                    value.AverageWriteLatency.IncrementBy((long)latencyMsec);
                    value.AverageWriteLatencyBase.Increment();
                }
            }
            if (value != null)
            {
                value.AverageOverallLatency.IncrementBy((long)latencyMsec);
                value.AverageOverallLatencyBase.Increment();
                ADProviderPerf.perProcessPercentileGlsLatency.AddValue((long)latencyMsec);
                uint num = (uint)ADProviderPerf.perProcessPercentileGlsLatency.PercentileQuery(95.0);
                value.NinetyFifthPercentileLatency.IncrementBy((long)((ulong)num));
                value.NinetyFifthPercentileLatencyBase.Increment();
                num = (uint)ADProviderPerf.perProcessPercentileGlsLatency.PercentileQuery(99.0);
                value.NinetyNinthPercentileLatency.IncrementBy((long)((ulong)num));
                value.NinetyNinthPercentileLatencyBase.Increment();
                lock (ADProviderPerf.slidingTotalLockRoot)
                {
                    if (success)
                    {
                        ADProviderPerf.successesPerMinute.AddValue(1L);
                    }
                    else
                    {
                        ADProviderPerf.failuresPerMinute.AddValue(1L);
                    }
                }
                ADProviderPerf.InitializeTimerIfRequired();
            }
            switch (apiName)
            {
            case "FindTenant":
                GlsApiPerformanceCounters.FindTenantAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.FindTenantAverageOverallLatencyBase.Increment();
                return;

            case "FindDomain":
            case "FindDomains":
                GlsApiPerformanceCounters.FindDomainAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.FindDomainAverageOverallLatencyBase.Increment();
                return;

            case "FindUser":
                GlsApiPerformanceCounters.FindUserAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.FindUserAverageOverallLatencyBase.Increment();
                return;

            case "SaveTenant":
                GlsApiPerformanceCounters.SaveTenantAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.SaveTenantAverageOverallLatencyBase.Increment();
                return;

            case "SaveDomain":
                GlsApiPerformanceCounters.SaveDomainAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.SaveDomainAverageOverallLatencyBase.Increment();
                return;

            case "SaveUser":
                GlsApiPerformanceCounters.SaveUserAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.SaveUserAverageOverallLatencyBase.Increment();
                return;

            case "DeleteTenant":
                GlsApiPerformanceCounters.DeleteTenantAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.DeleteTenantAverageOverallLatencyBase.Increment();
                return;

            case "DeleteDomain":
                GlsApiPerformanceCounters.DeleteDomainAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.DeleteDomainAverageOverallLatencyBase.Increment();
                return;

            case "DeleteUser":
                GlsApiPerformanceCounters.DeleteUserAverageOverallLatency.IncrementBy((long)latencyMsec);
                GlsApiPerformanceCounters.DeleteUserAverageOverallLatencyBase.Increment();
                return;
            }
            throw new ArgumentException("Unknown API " + apiName);
        }