rocksdb-native 0.0.0 → 0.0.1

package/vendor/rocksdb/tools/advisor/advisor/db_options_parser.py

@@ -1,348 +0,0 @@
-# Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-#  This source code is licensed under both the GPLv2 (found in the
-#  COPYING file in the root directory) and Apache 2.0 License
-#  (found in the LICENSE.Apache file in the root directory).
-
-import copy
-import os
-
-from advisor.db_log_parser import DataSource, NO_COL_FAMILY
-from advisor.ini_parser import IniParser
-
-
-class OptionsSpecParser(IniParser):
-    @staticmethod
-    def is_new_option(line):
-        return "=" in line
-
-    @staticmethod
-    def get_section_type(line):
-        """
-        Example section header: [TableOptions/BlockBasedTable "default"]
-        Here ConfigurationOptimizer returned would be
-        'TableOptions.BlockBasedTable'
-        """
-        section_path = line.strip()[1:-1].split()[0]
-        section_type = ".".join(section_path.split("/"))
-        return section_type
-
-    @staticmethod
-    def get_section_name(line):
-        # example: get_section_name('[CFOptions "default"]')
-        token_list = line.strip()[1:-1].split('"')
-        # token_list = ['CFOptions', 'default', '']
-        if len(token_list) < 3:
-            return None
-        return token_list[1]  # return 'default'
-
-    @staticmethod
-    def get_section_str(section_type, section_name):
-        # Example:
-        # Case 1: get_section_str('DBOptions', NO_COL_FAMILY)
-        # Case 2: get_section_str('TableOptions.BlockBasedTable', 'default')
-        section_type = "/".join(section_type.strip().split("."))
-        # Case 1: section_type = 'DBOptions'
-        # Case 2: section_type = 'TableOptions/BlockBasedTable'
-        section_str = "[" + section_type
-        if section_name == NO_COL_FAMILY:
-            # Case 1: '[DBOptions]'
-            return section_str + "]"
-        else:
-            # Case 2: '[TableOptions/BlockBasedTable "default"]'
-            return section_str + ' "' + section_name + '"]'
-
-    @staticmethod
-    def get_option_str(key, values):
-        option_str = key + "="
-        # get_option_str('db_log_dir', None), returns 'db_log_dir='
-        if values:
-            # example:
-            # get_option_str('max_bytes_for_level_multiplier_additional',
-            # [1,1,1,1,1,1,1]), returned string:
-            # 'max_bytes_for_level_multiplier_additional=1:1:1:1:1:1:1'
-            if isinstance(values, list):
-                for value in values:
-                    option_str += str(value) + ":"
-                option_str = option_str[:-1]
-            else:
-                # example: get_option_str('write_buffer_size', 1048576)
-                # returned string: 'write_buffer_size=1048576'
-                option_str += str(values)
-        return option_str
-
-
-class DatabaseOptions(DataSource):
-    @staticmethod
-    def is_misc_option(option_name):
-        # these are miscellaneous options that are not yet supported by the
-        # Rocksdb options file, hence they are not prefixed with any section
-        # name
-        return "." not in option_name
-
-    @staticmethod
-    def get_options_diff(opt_old, opt_new):
-        # type: Dict[option, Dict[col_fam, value]] X 2 ->
-        # Dict[option, Dict[col_fam, Tuple(old_value, new_value)]]
-        # note: diff should contain a tuple of values only if they are
-        # different from each other
-        options_union = set(opt_old.keys()).union(set(opt_new.keys()))
-        diff = {}
-        for opt in options_union:
-            diff[opt] = {}
-            # if option in options_union, then it must be in one of the configs
-            if opt not in opt_old:
-                for col_fam in opt_new[opt]:
-                    diff[opt][col_fam] = (None, opt_new[opt][col_fam])
-            elif opt not in opt_new:
-                for col_fam in opt_old[opt]:
-                    diff[opt][col_fam] = (opt_old[opt][col_fam], None)
-            else:
-                for col_fam in opt_old[opt]:
-                    if col_fam in opt_new[opt]:
-                        if opt_old[opt][col_fam] != opt_new[opt][col_fam]:
-                            diff[opt][col_fam] = (
-                                opt_old[opt][col_fam],
-                                opt_new[opt][col_fam],
-                            )
-                    else:
-                        diff[opt][col_fam] = (opt_old[opt][col_fam], None)
-                for col_fam in opt_new[opt]:
-                    if col_fam in opt_old[opt]:
-                        if opt_old[opt][col_fam] != opt_new[opt][col_fam]:
-                            diff[opt][col_fam] = (
-                                opt_old[opt][col_fam],
-                                opt_new[opt][col_fam],
-                            )
-                    else:
-                        diff[opt][col_fam] = (None, opt_new[opt][col_fam])
-            if not diff[opt]:
-                diff.pop(opt)
-        return diff
-
-    def __init__(self, rocksdb_options, misc_options=None):
-        super().__init__(DataSource.Type.DB_OPTIONS)
-        # The options are stored in the following data structure:
-        # Dict[section_type, Dict[section_name, Dict[option_name, value]]]
-        self.options_dict = None
-        self.column_families = None
-        # Load the options from the given file to a dictionary.
-        self.load_from_source(rocksdb_options)
-        # Setup the miscellaneous options expected to be List[str], where each
-        # element in the List has the format "<option_name>=<option_value>"
-        # These options are the ones that are not yet supported by the Rocksdb
-        # OPTIONS file, so they are provided separately
-        self.setup_misc_options(misc_options)
-
-    def setup_misc_options(self, misc_options):
-        self.misc_options = {}
-        if misc_options:
-            for option_pair_str in misc_options:
-                option_name = option_pair_str.split("=")[0].strip()
-                option_value = option_pair_str.split("=")[1].strip()
-                self.misc_options[option_name] = option_value
-
-    def load_from_source(self, options_path):
-        self.options_dict = {}
-        with open(options_path, "r") as db_options:
-            for line in db_options:
-                line = OptionsSpecParser.remove_trailing_comment(line)
-                if not line:
-                    continue
-                if OptionsSpecParser.is_section_header(line):
-                    curr_sec_type = OptionsSpecParser.get_section_type(line)
-                    curr_sec_name = OptionsSpecParser.get_section_name(line)
-                    if curr_sec_type not in self.options_dict:
-                        self.options_dict[curr_sec_type] = {}
-                    if not curr_sec_name:
-                        curr_sec_name = NO_COL_FAMILY
-                    self.options_dict[curr_sec_type][curr_sec_name] = {}
-                    # example: if the line read from the Rocksdb OPTIONS file
-                    # is [CFOptions "default"], then the section type is
-                    # CFOptions and 'default' is the name of a column family
-                    # that for this database, so it's added to the list of
-                    # column families stored in this object
-                    if curr_sec_type == "CFOptions":
-                        if not self.column_families:
-                            self.column_families = []
-                        self.column_families.append(curr_sec_name)
-                elif OptionsSpecParser.is_new_option(line):
-                    key, value = OptionsSpecParser.get_key_value_pair(line)
-                    self.options_dict[curr_sec_type][curr_sec_name][key] = value
-                else:
-                    error = "Not able to parse line in Options file."
-                    OptionsSpecParser.exit_with_parse_error(line, error)
-
-    def get_misc_options(self):
-        # these are options that are not yet supported by the Rocksdb OPTIONS
-        # file, hence they are provided and stored separately
-        return self.misc_options
-
-    def get_column_families(self):
-        return self.column_families
-
-    def get_all_options(self):
-        # This method returns all the options that are stored in this object as
-        # a: Dict[<sec_type>.<option_name>: Dict[col_fam, option_value]]
-        all_options = []
-        # Example: in the section header '[CFOptions "default"]' read from the
-        # OPTIONS file, sec_type='CFOptions'
-        for sec_type in self.options_dict:
-            for col_fam in self.options_dict[sec_type]:
-                for opt_name in self.options_dict[sec_type][col_fam]:
-                    option = sec_type + "." + opt_name
-                    all_options.append(option)
-        all_options.extend(list(self.misc_options.keys()))
-        return self.get_options(all_options)
-
-    def get_options(self, reqd_options):
-        # type: List[str] -> Dict[str, Dict[str, Any]]
-        # List[option] -> Dict[option, Dict[col_fam, value]]
-        reqd_options_dict = {}
-        for option in reqd_options:
-            if DatabaseOptions.is_misc_option(option):
-                # the option is not prefixed by '<section_type>.' because it is
-                # not yet supported by the Rocksdb OPTIONS file; so it has to
-                # be fetched from the misc_options dictionary
-                if option not in self.misc_options:
-                    continue
-                if option not in reqd_options_dict:
-                    reqd_options_dict[option] = {}
-                reqd_options_dict[option][NO_COL_FAMILY] = self.misc_options[option]
-            else:
-                # Example: option = 'TableOptions.BlockBasedTable.block_align'
-                # then, sec_type = 'TableOptions.BlockBasedTable'
-                sec_type = ".".join(option.split(".")[:-1])
-                # opt_name = 'block_align'
-                opt_name = option.split(".")[-1]
-                if sec_type not in self.options_dict:
-                    continue
-                for col_fam in self.options_dict[sec_type]:
-                    if opt_name in self.options_dict[sec_type][col_fam]:
-                        if option not in reqd_options_dict:
-                            reqd_options_dict[option] = {}
-                        reqd_options_dict[option][col_fam] = self.options_dict[
-                            sec_type
-                        ][col_fam][opt_name]
-        return reqd_options_dict
-
-    def update_options(self, options):
-        # An example 'options' object looks like:
-        # {'DBOptions.max_background_jobs': {NO_COL_FAMILY: 2},
-        # 'CFOptions.write_buffer_size': {'default': 1048576, 'cf_A': 128000},
-        # 'bloom_bits': {NO_COL_FAMILY: 4}}
-        for option in options:
-            if DatabaseOptions.is_misc_option(option):
-                # this is a misc_option i.e. an option that is not yet
-                # supported by the Rocksdb OPTIONS file, so it is not prefixed
-                # by '<section_type>.' and must be stored in the separate
-                # misc_options dictionary
-                if NO_COL_FAMILY not in options[option]:
-                    print(
-                        "WARNING(DatabaseOptions.update_options): not "
-                        + "updating option "
-                        + option
-                        + " because it is in "
-                        + "misc_option format but its scope is not "
-                        + NO_COL_FAMILY
-                        + ". Check format of option."
-                    )
-                    continue
-                self.misc_options[option] = options[option][NO_COL_FAMILY]
-            else:
-                sec_name = ".".join(option.split(".")[:-1])
-                opt_name = option.split(".")[-1]
-                if sec_name not in self.options_dict:
-                    self.options_dict[sec_name] = {}
-                for col_fam in options[option]:
-                    # if the option is not already present in the dictionary,
-                    # it will be inserted, else it will be updated to the new
-                    # value
-                    if col_fam not in self.options_dict[sec_name]:
-                        self.options_dict[sec_name][col_fam] = {}
-                    self.options_dict[sec_name][col_fam][opt_name] = copy.deepcopy(
-                        options[option][col_fam]
-                    )
-
-    def generate_options_config(self, nonce):
-        # this method generates a Rocksdb OPTIONS file in the INI format from
-        # the options stored in self.options_dict
-        this_path = os.path.abspath(os.path.dirname(__file__))
-        file_name = "../temp/OPTIONS_" + str(nonce) + ".tmp"
-        file_path = os.path.join(this_path, file_name)
-        with open(file_path, "w") as fp:
-            for section in self.options_dict:
-                for col_fam in self.options_dict[section]:
-                    fp.write(OptionsSpecParser.get_section_str(section, col_fam) + "\n")
-                    for option in self.options_dict[section][col_fam]:
-                        values = self.options_dict[section][col_fam][option]
-                        fp.write(
-                            OptionsSpecParser.get_option_str(option, values) + "\n"
-                        )
-                fp.write("\n")
-        return file_path
-
-    def check_and_trigger_conditions(self, conditions):
-        for cond in conditions:
-            reqd_options_dict = self.get_options(cond.options)
-            # This contains the indices of options that are specific to some
-            # column family and are not database-wide options.
-            incomplete_option_ix = []
-            options = []
-            missing_reqd_option = False
-            for ix, option in enumerate(cond.options):
-                if option not in reqd_options_dict:
-                    print(
-                        "WARNING(DatabaseOptions.check_and_trigger): "
-                        + "skipping condition "
-                        + cond.name
-                        + " because it "
-                        "requires option "
-                        + option
-                        + " but this option is"
-                        + " not available"
-                    )
-                    missing_reqd_option = True
-                    break  # required option is absent
-                if NO_COL_FAMILY in reqd_options_dict[option]:
-                    options.append(reqd_options_dict[option][NO_COL_FAMILY])
-                else:
-                    options.append(None)
-                    incomplete_option_ix.append(ix)
-
-            if missing_reqd_option:
-                continue
-
-            # if all the options are database-wide options
-            if not incomplete_option_ix:
-                try:
-                    if eval(cond.eval_expr):
-                        cond.set_trigger({NO_COL_FAMILY: options})
-                except Exception as e:
-                    print("WARNING(DatabaseOptions) check_and_trigger:" + str(e))
-                continue
-
-            # for all the options that are not database-wide, we look for their
-            # values specific to column families
-            col_fam_options_dict = {}
-            for col_fam in self.column_families:
-                present = True
-                for ix in incomplete_option_ix:
-                    option = cond.options[ix]
-                    if col_fam not in reqd_options_dict[option]:
-                        present = False
-                        break
-                    options[ix] = reqd_options_dict[option][col_fam]
-                if present:
-                    try:
-                        if eval(cond.eval_expr):
-                            col_fam_options_dict[col_fam] = copy.deepcopy(options)
-                    except Exception as e:
-                        print("WARNING(DatabaseOptions) check_and_trigger: " + str(e))
-            # Trigger for an OptionCondition object is of the form:
-            # Dict[col_fam_name: List[option_value]]
-            # where col_fam_name is the name of a column family for which
-            # 'eval_expr' evaluated to True and List[option_value] is the list
-            # of values of the options specified in the condition's 'options'
-            # field
-            if col_fam_options_dict:
-                cond.set_trigger(col_fam_options_dict)

package/vendor/rocksdb/tools/advisor/advisor/db_stats_fetcher.py

@@ -1,346 +0,0 @@
-# Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-#  This source code is licensed under both the GPLv2 (found in the
-#  COPYING file in the root directory) and Apache 2.0 License
-#  (found in the LICENSE.Apache file in the root directory).
-
-import copy
-import glob
-import re
-import subprocess
-import time
-from typing import List
-
-from advisor.db_log_parser import Log
-from advisor.db_timeseries_parser import NO_ENTITY, TimeSeriesData
-
-
-class LogStatsParser(TimeSeriesData):
-    STATS = "STATISTICS:"
-
-    @staticmethod
-    def parse_log_line_for_stats(log_line):
-        # Example stat line (from LOG file):
-        # "rocksdb.db.get.micros P50 : 8.4 P95 : 21.8 P99 : 33.9 P100 : 92.0\n"
-        token_list = log_line.strip().split()
-        # token_list = ['rocksdb.db.get.micros', 'P50', ':', '8.4', 'P95', ':',
-        # '21.8', 'P99', ':', '33.9', 'P100', ':', '92.0']
-        stat_prefix = token_list[0] + "."  # 'rocksdb.db.get.micros.'
-        stat_values = [token for token in token_list[1:] if token != ":"]
-        # stat_values = ['P50', '8.4', 'P95', '21.8', 'P99', '33.9', 'P100',
-        # '92.0']
-        stat_dict = {}
-        for ix, metric in enumerate(stat_values):
-            if ix % 2 == 0:
-                stat_name = stat_prefix + metric
-                stat_name = stat_name.lower()  # Note: case insensitive names
-            else:
-                stat_dict[stat_name] = float(metric)
-        # stat_dict = {'rocksdb.db.get.micros.p50': 8.4,
-        # 'rocksdb.db.get.micros.p95': 21.8, 'rocksdb.db.get.micros.p99': 33.9,
-        # 'rocksdb.db.get.micros.p100': 92.0}
-        return stat_dict
-
-    def __init__(self, logs_path_prefix, stats_freq_sec):
-        super().__init__()
-        self.logs_file_prefix = logs_path_prefix
-        self.stats_freq_sec = stats_freq_sec
-        self.duration_sec = 60
-
-    def get_keys_from_conditions(self, conditions):
-        # Note: case insensitive stat names
-        reqd_stats = []
-        for cond in conditions:
-            for key in cond.keys:
-                key = key.lower()
-                # some keys are prepended with '[]' for OdsStatsFetcher to
-                # replace this with the appropriate key_prefix, remove these
-                # characters here since the LogStatsParser does not need
-                # a prefix
-                if key.startswith("[]"):
-                    reqd_stats.append(key[2:])
-                else:
-                    reqd_stats.append(key)
-        return reqd_stats
-
-    def add_to_timeseries(self, log, reqd_stats):
-        # this method takes in the Log object that contains the Rocksdb stats
-        # and a list of required stats, then it parses the stats line by line
-        # to fetch required stats and add them to the keys_ts object
-        # Example: reqd_stats = ['rocksdb.block.cache.hit.count',
-        # 'rocksdb.db.get.micros.p99']
-        # Let log.get_message() returns following string:
-        # "[WARN] [db/db_impl.cc:485] STATISTICS:\n
-        # rocksdb.block.cache.miss COUNT : 1459\n
-        # rocksdb.block.cache.hit COUNT : 37\n
-        # ...
-        # rocksdb.db.get.micros P50 : 15.6 P95 : 39.7 P99 : 62.6 P100 : 148.0\n
-        # ..."
-        new_lines = log.get_message().split("\n")
-        # let log_ts = 1532518219
-        log_ts = log.get_timestamp()
-        # example updates to keys_ts:
-        # keys_ts[NO_ENTITY]['rocksdb.db.get.micros.p99'][1532518219] = 62.6
-        # keys_ts[NO_ENTITY]['rocksdb.block.cache.hit.count'][1532518219] = 37
-        for line in new_lines[1:]:  # new_lines[0] does not contain any stats
-            stats_on_line = self.parse_log_line_for_stats(line)
-            for stat in stats_on_line:
-                if stat in reqd_stats:
-                    if stat not in self.keys_ts[NO_ENTITY]:
-                        self.keys_ts[NO_ENTITY][stat] = {}
-                    self.keys_ts[NO_ENTITY][stat][log_ts] = stats_on_line[stat]
-
-    def fetch_timeseries(self, reqd_stats):
-        # this method parses the Rocksdb LOG file and generates timeseries for
-        # each of the statistic in the list reqd_stats
-        self.keys_ts = {NO_ENTITY: {}}
-        for file_name in glob.glob(self.logs_file_prefix + "*"):
-            # TODO(poojam23): find a way to distinguish between 'old' log files
-            # from current and previous experiments, present in the same
-            # directory
-            if re.search("old", file_name, re.IGNORECASE):
-                continue
-            with open(file_name, "r") as db_logs:
-                new_log = None
-                for line in db_logs:
-                    if Log.is_new_log(line):
-                        if new_log and re.search(self.STATS, new_log.get_message()):
-                            self.add_to_timeseries(new_log, reqd_stats)
-                        new_log = Log(line, column_families=[])
-                    else:
-                        # To account for logs split into multiple lines
-                        new_log.append_message(line)
-            # Check for the last log in the file.
-            if new_log and re.search(self.STATS, new_log.get_message()):
-                self.add_to_timeseries(new_log, reqd_stats)
-
-
-class DatabasePerfContext(TimeSeriesData):
-    # TODO(poojam23): check if any benchrunner provides PerfContext sampled at
-    # regular intervals
-    def __init__(self, perf_context_ts, stats_freq_sec, cumulative):
-        """
-        perf_context_ts is expected to be in the following format:
-        Dict[metric, Dict[timestamp, value]], where for
-        each (metric, timestamp) pair, the value is database-wide (i.e.
-        summed over all the threads involved)
-        if stats_freq_sec == 0, per-metric only one value is reported
-        """
-        super().__init__()
-        self.stats_freq_sec = stats_freq_sec
-        self.keys_ts = {NO_ENTITY: perf_context_ts}
-        if cumulative:
-            self.unaccumulate_metrics()
-
-    def unaccumulate_metrics(self):
-        # if the perf context metrics provided are cumulative in nature, this
-        # method can be used to convert them to a disjoint format
-        epoch_ts = copy.deepcopy(self.keys_ts)
-        for stat in self.keys_ts[NO_ENTITY]:
-            timeseries = sorted(
-                list(self.keys_ts[NO_ENTITY][stat].keys()), reverse=True
-            )
-            if len(timeseries) < 2:
-                continue
-            for ix, ts in enumerate(timeseries[:-1]):
-                epoch_ts[NO_ENTITY][stat][ts] = (
-                    epoch_ts[NO_ENTITY][stat][ts]
-                    - epoch_ts[NO_ENTITY][stat][timeseries[ix + 1]]
-                )
-                if epoch_ts[NO_ENTITY][stat][ts] < 0:
-                    raise ValueError("DBPerfContext: really cumulative?")
-            # drop the smallest timestamp in the timeseries for this metric
-            epoch_ts[NO_ENTITY][stat].pop(timeseries[-1])
-        self.keys_ts = epoch_ts
-
-    def get_keys_from_conditions(self, conditions):
-        reqd_stats = []
-        for cond in conditions:
-            reqd_stats.extend([key.lower() for key in cond.keys])
-        return reqd_stats
-
-    def fetch_timeseries(self, statistics):
-        # this method is redundant for DatabasePerfContext because the __init__
-        # does the job of populating 'keys_ts'
-        pass
-
-
-class OdsStatsFetcher(TimeSeriesData):
-    # class constants
-    OUTPUT_FILE = "temp/stats_out.tmp"
-    ERROR_FILE = "temp/stats_err.tmp"
-    RAPIDO_COMMAND = "%s --entity=%s --key=%s --tstart=%s --tend=%s --showtime"
-
-    # static methods
-    @staticmethod
-    def _get_string_in_quotes(value):
-        return '"' + str(value) + '"'
-
-    @staticmethod
-    def _get_time_value_pair(pair_string):
-        # example pair_string: '[1532544591, 97.3653601828]'
-        pair_string = pair_string.replace("[", "")
-        pair_string = pair_string.replace("]", "")
-        pair = pair_string.split(",")
-        first = int(pair[0].strip())
-        second = float(pair[1].strip())
-        return [first, second]
-
-    @staticmethod
-    def _get_ods_cli_stime(start_time):
-        diff = int(time.time() - int(start_time))
-        stime = str(diff) + "_s"
-        return stime
-
-    def __init__(self, client, entities, start_time, end_time, key_prefix=None):
-        super().__init__()
-        self.client = client
-        self.entities = entities
-        self.start_time = start_time
-        self.end_time = end_time
-        self.key_prefix = key_prefix
-        self.stats_freq_sec = 60
-        self.duration_sec = 60
-
-    def execute_script(self, command):
-        print("executing...")
-        print(command)
-        out_file = open(self.OUTPUT_FILE, "w+")
-        err_file = open(self.ERROR_FILE, "w+")
-        subprocess.call(command, shell=True, stdout=out_file, stderr=err_file)
-        out_file.close()
-        err_file.close()
-
-    def parse_rapido_output(self):
-        # Output looks like the following:
-        # <entity_name>\t<key_name>\t[[ts, value], [ts, value], ...]
-        # ts = timestamp; value = value of key_name in entity_name at time ts
-        self.keys_ts = {}
-        with open(self.OUTPUT_FILE, "r") as fp:
-            for line in fp:
-                token_list = line.strip().split("\t")
-                entity = token_list[0]
-                key = token_list[1]
-                if entity not in self.keys_ts:
-                    self.keys_ts[entity] = {}
-                if key not in self.keys_ts[entity]:
-                    self.keys_ts[entity][key] = {}
-                list_of_lists = [
-                    self._get_time_value_pair(pair_string)
-                    for pair_string in token_list[2].split("],")
-                ]
-                value = {pair[0]: pair[1] for pair in list_of_lists}
-                self.keys_ts[entity][key] = value
-
-    def parse_ods_output(self):
-        # Output looks like the following:
-        # <entity_name>\t<key_name>\t<timestamp>\t<value>
-        # there is one line per (entity_name, key_name, timestamp)
-        self.keys_ts = {}
-        with open(self.OUTPUT_FILE, "r") as fp:
-            for line in fp:
-                token_list = line.split()
-                entity = token_list[0]
-                if entity not in self.keys_ts:
-                    self.keys_ts[entity] = {}
-                key = token_list[1]
-                if key not in self.keys_ts[entity]:
-                    self.keys_ts[entity][key] = {}
-                self.keys_ts[entity][key][token_list[2]] = token_list[3]
-
-    def fetch_timeseries(self, statistics):
-        # this method fetches the timeseries of required stats from the ODS
-        # service and populates the 'keys_ts' object appropriately
-        print("OdsStatsFetcher: fetching " + str(statistics))
-        if re.search("rapido", self.client, re.IGNORECASE):
-            command = self.RAPIDO_COMMAND % (
-                self.client,
-                self._get_string_in_quotes(self.entities),
-                self._get_string_in_quotes(",".join(statistics)),
-                self._get_string_in_quotes(self.start_time),
-                self._get_string_in_quotes(self.end_time),
-            )
-            # Run the tool and fetch the time-series data
-            self.execute_script(command)
-            # Parse output and populate the 'keys_ts' map
-            self.parse_rapido_output()
-        elif re.search("ods", self.client, re.IGNORECASE):
-            command = (
-                self.client
-                + " "
-                + "--stime="
-                + self._get_ods_cli_stime(self.start_time)
-                + " "
-                + self._get_string_in_quotes(self.entities)
-                + " "
-                + self._get_string_in_quotes(",".join(statistics))
-            )
-            # Run the tool and fetch the time-series data
-            self.execute_script(command)
-            # Parse output and populate the 'keys_ts' map
-            self.parse_ods_output()
-
-    def get_keys_from_conditions(self, conditions):
-        reqd_stats = []
-        for cond in conditions:
-            for key in cond.keys:
-                use_prefix = False
-                if key.startswith("[]"):
-                    use_prefix = True
-                    key = key[2:]
-                # TODO(poojam23): this is very hacky and needs to be improved
-                if key.startswith("rocksdb"):
-                    key += ".60"
-                if use_prefix:
-                    if not self.key_prefix:
-                        print("Warning: OdsStatsFetcher might need key prefix")
-                        print("for the key: " + key)
-                    else:
-                        key = self.key_prefix + "." + key
-                reqd_stats.append(key)
-        return reqd_stats
-
-    def fetch_rate_url(
-        self,
-        entities: List[str],
-        keys: List[str],
-        window_len: str,
-        percent: str,
-        display: bool,
-    ) -> str:
-        transform_desc = (
-            "rate(" + str(window_len) + ",duration=" + str(self.duration_sec)
-        )
-        if percent:
-            transform_desc = transform_desc + ",%)"
-        else:
-            transform_desc = transform_desc + ")"
-        if re.search("rapido", self.client, re.IGNORECASE):
-            command = self.RAPIDO_COMMAND + " --transform=%s --url=%s"
-            command = command % (
-                self.client,
-                self._get_string_in_quotes(",".join(entities)),
-                self._get_string_in_quotes(",".join(keys)),
-                self._get_string_in_quotes(self.start_time),
-                self._get_string_in_quotes(self.end_time),
-                self._get_string_in_quotes(transform_desc),
-                self._get_string_in_quotes(display),
-            )
-        elif re.search("ods", self.client, re.IGNORECASE):
-            command = (
-                self.client
-                + " "
-                + "--stime="
-                + self._get_ods_cli_stime(self.start_time)
-                + " "
-                + "--fburlonly "
-                + self._get_string_in_quotes(entities)
-                + " "
-                + self._get_string_in_quotes(",".join(keys))
-                + " "
-                + self._get_string_in_quotes(transform_desc)
-            )
-        self.execute_script(command)
-        url = ""
-        with open(self.OUTPUT_FILE, "r") as fp:
-            url = fp.readline()
-        return url