Python metric.Metric类代码示例

def parse_metric_section(config_obj, section, metric_classes,  metrics, aggregate_metric_classes, outdir_default, resource_path):
  """
  Parse a metric section and create a Metric object
  :param config_obj: ConfigParser object
  :param section: Section name
  :param metric_classes: List of valid metric types
  :param metrics: List of all regular metric objects (used by aggregate metric)
  :param aggregate_metric_classes: List of all valid aggregate metric types
  :param outdir_default: Default output directory
  :param resource_path: Default resource directory
  :return: An initialized Metric object
  """
  hostname, infile, aggr_hosts, aggr_metrics, label, ts_start, ts_end, precision, kwargs, rule_strings = parse_basic_metric_options(config_obj, section)
  #TODO: Make user specify metric_type in config and not infer from section
  metric_type = section.split('-')[0]
  if metric_type in metric_classes: # regular metrics
    new_metric = metric_classes[metric_type](section, infile, hostname, outdir_default, resource_path, label, ts_start, ts_end, rule_strings, **kwargs)
  elif metric_type in aggregate_metric_classes:       #aggregate metrics     
    new_metric = aggregate_metric_classes[metric_type](section, aggr_hosts, aggr_metrics, metrics, outdir_default, resource_path, label, ts_start, ts_end, rule_strings, **kwargs)
  else:            # new metrics. 
    new_metric = Metric(section, infile, hostname, outdir_default, resource_path, label, ts_start, ts_end, rule_strings, **kwargs)

  if config_obj.has_option(section, 'ignore') and config_obj.getint(section, 'ignore') == 1:
    new_metric.ignore = True
  if config_obj.has_option(section, 'calc_metrics'):
    new_metric.calc_metrics = config_obj.get(section, 'calc_metrics')
  new_metric.precision = precision
  return new_metric

def initialize_metric(section, infile_list, hostname, output_directory, resource_path, label, ts_start, ts_end, rule_strings, important_sub_metrics, anomaly_detection_metrics, other_options):
  """
  Initialize appropriate metric based on type of metric.
  :param: section: config section name or auto discovered metric type
  :param: infile_list: list of input log files for the metric
  :param: hostname: hostname associated with the logs origin
  :param: output_directory: report location
  :param: resource_path: resource path for report
  :param: label: label for config section or auto discovered metric type
  :param: ts_start: start time for analysis
  :param: ts_end: end time for analysis
  :param: rule_strings: list of slas
  :param: important_sub_metrics: list of important sub metrics
  :param: anomaly_detection_metrics: list of metrics to use for anomaly detection.
  :param: other_options: kwargs
  :return: metric object
  """
  bin_path = os.path.abspath(os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),'bin'))
  metric = None
  metric_type = section.split('-')[0]
  if metric_type in metric_classes:
    if 'SAR' in metric_type:
      metric = metric_classes['SAR'](section, infile_list, hostname, output_directory, resource_path, label, ts_start, ts_end, rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options)
    else:
      metric = metric_classes[metric_type](section, infile_list, hostname, output_directory, resource_path, label, ts_start, ts_end, rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options)
  else:
    metric = Metric(section, infile_list, hostname, output_directory, resource_path, label, ts_start, ts_end, rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options)
  metric.bin_path = bin_path
  return metric

 def __init__ (self, metric_type, infile, hostname, output_directory, resource_path, label, ts_start, ts_end,
               rule_strings, **other_options):
   Metric.__init__(self, metric_type, infile, hostname, output_directory, resource_path, label, ts_start, ts_end,
                   rule_strings)
   self.sub_metric_description = {
     'lb': 'Transaction Name',
     'lt': 'Time to First byte',
     'ts': 'Timestamp',
     'tn': 'Transaction Name (Parent)',
     's': 'Status',
     'ResponseTime': 'Response Time',
     'rc': 'Response Code',
     'rm': 'Response Message',
     'dt': 'Data Type',
     'ResponseSize': 'Response Size',
     'qps': 'Successful Transactions per second',
     'ErrorsPerSecond': 'Errors per second',
     'DataThroughput': 'Data Throughput'
   }
   self.sub_metric_units = {
     'lt': 'ms',
     'ResponseTime': 'ms',
     'ResponseSize': 'bytes',
     'qps': 'qps',
     'DataThroughput': 'mbps',
     'ErrorsPerSecond': 'qps'
   }
   self.calculated_stats = {}
   self.aggregation_granularity = 'minute'
   self.calculated_percentiles = {}
   self.summary_stats = defaultdict(dict)
   self.important_sub_metrics = naarad.naarad_imports.important_sub_metrics_import['JMETER']
   if other_options:
     for (key, val) in other_options.iteritems():
       setattr(self, key, val)

 def __init__ (self, metric_type, infile, access, outdir, label, ts_start, ts_end, **other_options):
   Metric.__init__(self, metric_type, infile, access, outdir, label, ts_start, ts_end)
   for (key,val) in other_options.iteritems():
     if key == 'gc-options':
       self.gc_options = val.split()
     else:
       setattr(self, key, val)
   self.metric_description = {
     "appstop" :"approximate application stop times",
     "gen0" :" young gen collection time, excluding gc_prologue & gc_epilogue",
     "gen0t" :" young gen collection time, including gc_prologue & gc_epilogue",
     "gen0usr" :" young gen collection time in cpu user secs",
     "gen0sys" :" young gen collection time in cpu sys secs",
     "gen1i" :" train generation incremental collection",
     "gen1t" :" old generation collection/full GC",
     "cmsIM" :" CMS initial mark pause",
     "cmsRM" :" CMS remark pause",
     "cmsRS" :" CMS resize pause",
     "GC" :" all stop-the-world GC pauses",
     "cmsCM" :" CMS concurrent mark phase",
     "cmsCP" :" CMS concurrent preclean phase",
     "cmsCS" :" CMS concurrent sweep phase",
     "cmsCR" :" CMS concurrent reset phase",
     "alloc":" object allocation in MB (approximate***)",
     "promo":" object promotion in MB (approximate***)",
     "used0":" young gen used memory size (before gc)",
     "used1":" old gen used memory size (before gc)",
     "used":" heap space used memory size (before gc) (excludes perm gen)",
     "commit0":" young gen committed memory size (after gc)",
     "commit1":" old gen committed memory size (after gc)",
     "commit":" heap committed memory size (after gc) (excludes perm gen)",
     "apptime" :" amount of time application threads were running",
     "safept" :" amount of time the VM spent at safepoints (app threads stopped)"
     }

 def __init__ (self, metric_type, infile, hostname, outdir, resource_path, label, ts_start, ts_end, rule_strings,
               **other_options):
   Metric.__init__(self, metric_type, infile, hostname, outdir, resource_path, label, ts_start, ts_end, rule_strings)
   self.sub_metrics = self.val_types
   self.sub_metric_description = {
     "launch_time" :"the time taken to launch the client application",
     "nus_update_time" :"the time taken to update NUS list after launch"
   }

  def __init__(self, metric_type, infile_list, hostname, output_directory, resource_path, label, ts_start, ts_end,
               rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options):
    Metric.__init__(self, metric_type, infile_list, hostname, output_directory, resource_path, label, ts_start, ts_end,
                    rule_strings, important_sub_metrics, anomaly_detection_metrics)
    self.sub_metrics = None
    for (key, val) in other_options.iteritems():
      setattr(self, key, val.split())

    self._extract_input_connections()
    self._extract_input_processes()

 def __init__(self, metric_type, infile, hostname, outdir, resource_path, label, ts_start, ts_end, rule_strings,
              **other_options):
   metric_type = self.extract_metric_name(metric_type)
   Metric.__init__(self, metric_type, infile,  hostname, outdir, resource_path, label, ts_start, ts_end, rule_strings)
   if self.metric_type in important_sub_metrics_import.keys():
     self.important_sub_metrics = important_sub_metrics_import[self.metric_type]
   self.options = None
   self.devices = None
   for (key, val) in other_options.iteritems():
     setattr(self, key, val.split())

  def __init__(self, metric_type, infile, hostname, aggr_metrics, output_directory, resource_path, label, ts_start, ts_end,
               rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options):
    Metric.__init__(self, metric_type, infile, hostname, aggr_metrics, output_directory, resource_path, label, ts_start, ts_end,
                    rule_strings, important_sub_metrics, anomaly_detection_metrics)

    # Allow user to specify interested processes; in the format of 'PID=11 22' and 'COMMAND=firefox top'
    # It will search for any processes that match the PIDs listed or the commands listed. It's not an intersection of the PIDs and commands.
    self.PID = []
    self.COMMAND = []
    self.ts_valid_lines = True

    for (key, val) in other_options.iteritems():
      setattr(self, key, val.split())

    self.sub_metrics = None
    self.process_headers = []
    self.ts = ''
    self.ts_date = ''
    self.ts_time = ''
    self.saw_pid = False   # Controls when to process individual commands;

    self.data = {}  # Stores all data to be written out

    for key, val in other_options.iteritems():
      setattr(self, key, val.split())

    self.sub_metric_description = {
        'uptime_minute': 'uptime of the machine',
        'num_users': 'users sessions logged in',
        'load_aver_1_minute': 'average load on the system (last 1 minute)',
        'load_aver_5_minute': 'average load on the system (last 5 minutes)',
        'load_aver_15_minute': 'average load on the system (last 15 minutes)',
        'tasks_total': 'total processes',
        'tasks_running': 'processes running',
        'tasks_sleeping': 'processes sleeping',
        'tasks_stopped': 'processes stopped',
        'tasks_zombie': 'zombies',
        'cpu_us': 'cpu percentage of running user processes',
        'cpu_sy': 'cpu percentage of running system processes',
        'cpu_id': 'cpu percentage of idel time',
        'cpu_ni': 'cpu percentage of running niced processes',
        'cpu_wa': 'cpu percentage of waiting for IO',
        'cpu_hi': 'cpu percentage of serving hardware IRQ',
        'cpu_si': 'cpu percentage of serving software IRQ',
        'cpu_st': 'cpu percentage of being stolen',
        'mem_total': 'total memory in GB',
        'mem_used': 'total memory in use in GB',
        'mem_free': 'total free memory in GB',
        'mem_buffers': 'total buffers in GB',
        'swap_total': 'total swap size in GB',
        'swap_used': 'total swap in use in GB',
        'swap_free': 'total free swap in GB',
        'swap_cached': 'total swap cache in GB',
    }

 def __init__(self, metric_type, infile_list, hostname, aggr_metrics, outdir, resource_path, label, ts_start, ts_end, rule_strings,
              important_sub_metrics, anomaly_detection_metrics, **other_options):
   Metric.__init__(self, metric_type, infile_list, hostname, aggr_metrics, outdir, resource_path, label, ts_start, ts_end, rule_strings,
                   important_sub_metrics, anomaly_detection_metrics)
   self.sub_metrics = self.val_types
   if not self.important_sub_metrics:
     self.important_sub_metrics = CONSTANTS.important_sub_metrics_import['LINKEDINANDROIDRUM']
   self.sub_metric_description = {
       "launch_time": "the time taken to launch the client application",
       "nus_update_time": "the time taken to update NUS list after launch"
   }

  def __init__(self, metric_type, infile_list, hostname, outdir, resource_path, label, ts_start, ts_end, rule_strings,
               important_sub_metrics, anomaly_detection_metrics, **other_options):
    Metric.__init__(self, metric_type, infile_list, hostname, outdir, resource_path, label, ts_start, ts_end, rule_strings,
                    important_sub_metrics, anomaly_detection_metrics)
    if not self.important_sub_metrics and self.metric_type in important_sub_metrics_import.keys():
      self.important_sub_metrics = important_sub_metrics_import[self.metric_type]
    self.options = None

    self.CPUS = None
    for (key, val) in other_options.iteritems():
      setattr(self, key, val.split())

  def __init__(self, section, aggregate_hosts, aggregate_metrics, metrics, output_directory, resource_path, label,
               ts_start, ts_end, rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options):
    self.metrics = metrics
    self.aggr_hosts = aggregate_hosts.split()

    # Metric arguments take 'infile' and 'hostname', for ClusterMetric, they are invalid, so just provide empty strings.
    Metric.__init__(self, section, '', '', '', output_directory, resource_path, label, ts_start, ts_end, rule_strings,
                    important_sub_metrics, anomaly_detection_metrics)
    self.aggr_metrics = aggregate_metrics.split()

    for (key, val) in other_options.iteritems():
      setattr(self, key, val.split())

 def __init__ (self, section, aggregate_hosts, aggregate_metrics, metrics, output_directory, resource_path, label, ts_start, ts_end,
               rule_strings, **other_options):
   self.metrics = metrics
   self.aggr_metrics = re.split(",| |:", aggregate_metrics)  #support both "," and " ", ":" as separator
   self.aggr_hosts = re.split(",| |:", aggregate_hosts) 
                 
   #Metric arguments take 'infile' and 'hostname', for ClusterMetric, they are invalid, so just provide empty strings.     
   Metric.__init__(self, section, '', '', output_directory, resource_path, label, ts_start, ts_end, rule_strings)
   
   # in particular, Section can specify a subset of all rows (default has 43 rows):  "sub_metrics=nr_free_pages nr_inactive_anon"
   for (key, val) in other_options.iteritems():
     setattr(self, key, val.split())   

  def __init__ (self, metric_type, infile_list, hostname, output_directory, resource_path, label, ts_start, ts_end,
                rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options):
    Metric.__init__(self, metric_type, infile_list, hostname, output_directory, resource_path, label, ts_start, ts_end,
                    rule_strings, important_sub_metrics, anomaly_detection_metrics)

    # in particular, Section can specify a subset of all rows (default has 43 rows):  "sub_metrics=nr_free_pages nr_inactive_anon"
    for (key, val) in other_options.iteritems():
      setattr(self, key, val.split())   
      
    self.sub_metric_description = {
      'MemTotal': 'Total memory in KB',
      'MemFree': 'Total free memory in KB',
      'Buffers': 'Size of buffers in KB',
      'Cached': 'Size of page cache in KB',
     }    

 def plot_timeseries(self, graphing_library='matplotlib'):
   if graphing_library != 'matplotlib':
     return Metric.plot_timeseries(self, graphing_library)
   else:
     logger.info('Using graphing_library {lib} for metric {name}'.format(lib=graphing_library, name=self.label))
     plot_data = {}
     # plot time series data for submetrics
     for out_csv in sorted(self.csv_files, reverse=True):
       csv_filename = os.path.basename(out_csv)
       # The last element is .csv, don't need that in the name of the chart
       column = csv_filename.split('.')[-2]
       transaction_name = ' '.join(csv_filename.split('.')[1:-2])
       plot = PD(input_csv=out_csv, csv_column=1, series_name=transaction_name,
                 y_label=self.sub_metric_description[column] + ' (' + self.sub_metric_units[column] + ')', precision=None, graph_height=500, graph_width=1200,
                 graph_type='line')
       if transaction_name in plot_data:
         plot_data[transaction_name].append(plot)
       else:
         plot_data[transaction_name] = [plot]
     for transaction in plot_data:
       graphed, div_file = Metric.graphing_modules[graphing_library].graph_data(plot_data[transaction], self.resource_directory, self.resource_path,
                                                                                self.label + '.' + transaction)
       if graphed:
         self.plot_files.append(div_file)
     return True

    def __init__(
        self,
        metric_type,
        infile_list,
        hostname,
        aggr_metrics,
        output_directory,
        resource_path,
        label,
        ts_start,
        ts_end,
        rule_strings,
        important_sub_metrics,
        anomaly_detection_metrics,
        **other_options
    ):
        Metric.__init__(
            self,
            metric_type,
            infile_list,
            hostname,
            aggr_metrics,
            output_directory,
            resource_path,
            label,
            ts_start,
            ts_end,
            rule_strings,
            important_sub_metrics,
            anomaly_detection_metrics,
        )

        self.sub_metrics = None
        # in particular, Section can specify a subset of all metrics: sub_metrics=pages.min nr_free_pages

        for (key, val) in other_options.iteritems():
            setattr(self, key, val.split())

        self.sub_metric_description = {
            "nr_free_pages": "Number of free pages",
            "nr_inactive_anon": "Number of inactive anonymous pages",
            "nr_active_anon": "Number of active anonymous pages",
            "nr_inactive_file": "Number of inactive file cache pages",
            "nr_active_file": "Number of active file cache pages",
        }