NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

__init__.py (5812B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\statscapture\__init__.py
      2 __author__ = 'snorri.sturluson'
      3 import logging
      4 import os
      5 import time
      6 import blue
      7 from statscapture.performancemeasurements import Measurement
      8 from victoriametrics.metrics_reporter import send_metrics_to_victoria_metrics
      9 
     10 class BaseCapture(object):
     11 
     12     def capture(self):
     13         raise NotImplementedError()
     14 
     15 
     16 class PercentileCapture(BaseCapture):
     17 
     18     def __init__(self, _, counter_list):
     19         self.percentileAccumulators = []
     20         self.captured_values = {}
     21         self.counter_list = counter_list
     22         for counter_name, start, step in counter_list:
     23             accumulator = blue.PercentileAccumulator()
     24             self.percentileAccumulators.append(accumulator)
     25             blue.statistics.SetAccumulator(counter_name, accumulator)
     26 
     27         self.reset()
     28 
     29     def reset(self):
     30         for accumulator in self.percentileAccumulators:
     31             accumulator.Clear()
     32 
     33     def capture(self):
     34         cutoff_point = 0.99
     35         step_size = 0.0001
     36         for i, counter_list in enumerate(self.counter_list):
     37             counter_name, start, step = counter_list
     38             self.captured_values[counter_name] = {'complete': {'values': self.percentileAccumulators[i].GetPercentiles(start, step),
     39                           'start_value': start,
     40                           'step_size': step},
     41              'tail': {'values': self.percentileAccumulators[i].GetValuesForPercentiles(cutoff_point, step_size),
     42                       'cutoff_point': cutoff_point,
     43                       'step_size': step_size}}
     44 
     45         return self.captured_values
     46 
     47 
     48 class StatsCapture(BaseCapture):
     49 
     50     def __init__(self, name, percentile_counters = ()):
     51         self.counters = {k:blue.statistics.Find(k) for k in blue.statistics.GetValues()}
     52         self.captured_values = {k:None for k in self.counters}
     53         self.start_time = time.clock()
     54         self.percentile_counter = PercentileCapture(name, percentile_counters)
     55         self.reset()
     56 
     57     def reset(self):
     58         blue.statistics.ResetPeaks()
     59         blue.statistics.ResetDerived()
     60         self.start_time = time.clock()
     61 
     62     def capture(self):
     63         self.captured_values['duration'] = time.clock() - self.start_time
     64         for name, counter in self.counters.iteritems():
     65             self.captured_values[name] = counter.value
     66 
     67         captured_percentile_data = self.percentile_counter.capture()
     68         if captured_percentile_data:
     69             self.captured_values['percentiles'] = captured_percentile_data
     70         self.percentile_counter = None
     71         return self.captured_values
     72 
     73 
     74 class FullStatsCapture(StatsCapture):
     75 
     76     def __init__(self, measurement_name, percentile_counters = (), stats_filter = ()):
     77         super(FullStatsCapture, self).__init__(percentile_counters)
     78         self.name = measurement_name
     79         self.save_dir = ''
     80         self.tags = []
     81         self.stat_filter = stats_filter
     82         self.measurement = Measurement(statFilter=self.stat_filter)
     83         self.measurement.Begin()
     84 
     85     def capture(self):
     86         self.measurement.TakeScreenshot()
     87         self.measurement.End()
     88         import socket
     89         results = super(FullStatsCapture, self).capture()
     90         try:
     91             self.measurement.Upload(self.name, {'name': 'EVE Probe',
     92              'server': socket.gethostname()}, tags=','.join(self.tags), saveDir=self.save_dir)
     93         except:
     94             logging.exception('error when uploading performance results to the server')
     95 
     96         return results
     97 
     98 
     99 class TeamcityStatsCapture(StatsCapture):
    100 
    101     def __init__(self, measurement_name, percentile_counters = (), stats_filter = (), save_dir = '', vm_server = None, machine_type = 'manual'):
    102         super(TeamcityStatsCapture, self).__init__(percentile_counters)
    103         self.name = measurement_name
    104         self.save_dir = save_dir
    105         self.stat_filter = stats_filter
    106         self.vm_server = vm_server
    107         self.machine_type = machine_type
    108         self.measurement = Measurement(statFilter=self.stat_filter)
    109         self.teamcity_stats_filter = ['Trinity/FrameTime',
    110          'FPS',
    111          'Blue/Memory/PageFileUsage',
    112          'Trinity/AL/GpuFrameTime',
    113          'Trinity/PresentTime']
    114         self.measurement.Begin()
    115 
    116     def capture(self):
    117         self.measurement.TakeScreenshot()
    118         self.measurement.End()
    119         results = super(TeamcityStatsCapture, self).capture()
    120         json_report = os.path.join(self.save_dir, 'measurement_teamcity.json')
    121         teamcity_report = os.path.join(self.save_dir, 'testlog.txt')
    122         self.measurement.Export(self.name, json_report, {'name': 'EVE Probe'})
    123         aggregatedStats = self.measurement.GetAggregatedStats(self.teamcity_stats_filter)
    124         self.log_stats_for_teamcity(aggregatedStats, teamcity_report)
    125         if self.vm_server:
    126             send_metrics_to_victoria_metrics(aggregatedStats, self.vm_server, machine_type=self.machine_type, metric_prefix='eve_probe_', measurement_name=self.name)
    127         return results
    128 
    129     def log_stats_for_teamcity(self, aggregatedStats, reportFile):
    130         if not os.path.exists(os.path.dirname(reportFile)):
    131             os.makedirs(os.path.dirname(reportFile))
    132         for statName, value in aggregatedStats.items():
    133             if statName == 'FPS':
    134                 value = value / 100.0
    135             elif statName in ('Trinity/FrameTime', 'Trinity/AL/GpuFrameTime', 'Trinity/PresentTime'):
    136                 value = value * 1000.0
    137             line_teamcity = "##teamcity[buildStatisticValue key='{0}' value='{1}']".format(statName, value)
    138             line_log = 'Measurement result for {0}: {1}'.format(statName, value)
    139             with open(reportFile, 'a') as f:
    140                 f.write(line_teamcity + '\n')
    141                 f.write(line_log + '\n')