rocksdb-native 0.0.0 → 0.0.1

package/vendor/rocksdb/tools/advisor/test/test_db_bench_runner.py

@@ -1,141 +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 os
-import unittest
-
-from advisor.db_bench_runner import DBBenchRunner
-from advisor.db_log_parser import DataSource, NO_COL_FAMILY
-from advisor.db_options_parser import DatabaseOptions
-
-
-class TestDBBenchRunnerMethods(unittest.TestCase):
-    def setUp(self):
-        self.pos_args = [
-            "./../../db_bench",
-            "overwrite",
-            "use_existing_db=true",
-            "duration=10",
-        ]
-        self.bench_runner = DBBenchRunner(self.pos_args)
-        this_path = os.path.abspath(os.path.dirname(__file__))
-        options_path = os.path.join(this_path, "input_files/OPTIONS-000005")
-        self.db_options = DatabaseOptions(options_path)
-
-    def test_setup(self):
-        self.assertEqual(self.bench_runner.db_bench_binary, self.pos_args[0])
-        self.assertEqual(self.bench_runner.benchmark, self.pos_args[1])
-        self.assertSetEqual(
-            set(self.bench_runner.db_bench_args), set(self.pos_args[2:])
-        )
-
-    def test_get_info_log_file_name(self):
-        log_file_name = DBBenchRunner.get_info_log_file_name(None, "random_path")
-        self.assertEqual(log_file_name, "LOG")
-
-        log_file_name = DBBenchRunner.get_info_log_file_name(
-            "/dev/shm/", "/tmp/rocksdbtest-155919/dbbench/"
-        )
-        self.assertEqual(log_file_name, "tmp_rocksdbtest-155919_dbbench_LOG")
-
-    def test_get_opt_args_str(self):
-        misc_opt_dict = {"bloom_bits": 2, "empty_opt": None, "rate_limiter": 3}
-        optional_args_str = DBBenchRunner.get_opt_args_str(misc_opt_dict)
-        self.assertEqual(optional_args_str, " --bloom_bits=2 --rate_limiter=3")
-
-    def test_get_log_options(self):
-        db_path = "/tmp/rocksdb-155919/dbbench"
-        # when db_log_dir is present in the db_options
-        update_dict = {
-            "DBOptions.db_log_dir": {NO_COL_FAMILY: "/dev/shm"},
-            "DBOptions.stats_dump_period_sec": {NO_COL_FAMILY: "20"},
-        }
-        self.db_options.update_options(update_dict)
-        log_file_prefix, stats_freq = self.bench_runner.get_log_options(
-            self.db_options, db_path
-        )
-        self.assertEqual(log_file_prefix, "/dev/shm/tmp_rocksdb-155919_dbbench_LOG")
-        self.assertEqual(stats_freq, 20)
-
-        update_dict = {
-            "DBOptions.db_log_dir": {NO_COL_FAMILY: None},
-            "DBOptions.stats_dump_period_sec": {NO_COL_FAMILY: "30"},
-        }
-        self.db_options.update_options(update_dict)
-        log_file_prefix, stats_freq = self.bench_runner.get_log_options(
-            self.db_options, db_path
-        )
-        self.assertEqual(log_file_prefix, "/tmp/rocksdb-155919/dbbench/LOG")
-        self.assertEqual(stats_freq, 30)
-
-    def test_build_experiment_command(self):
-        # add some misc_options to db_options
-        update_dict = {
-            "bloom_bits": {NO_COL_FAMILY: 2},
-            "rate_limiter_bytes_per_sec": {NO_COL_FAMILY: 128000000},
-        }
-        self.db_options.update_options(update_dict)
-        db_path = "/dev/shm"
-        experiment_command = self.bench_runner._build_experiment_command(
-            self.db_options, db_path
-        )
-        opt_args_str = DBBenchRunner.get_opt_args_str(
-            self.db_options.get_misc_options()
-        )
-        opt_args_str += " --options_file=" + self.db_options.generate_options_config(
-            "12345"
-        )
-        for arg in self.pos_args[2:]:
-            opt_args_str += " --" + arg
-        expected_command = (
-            self.pos_args[0]
-            + " --benchmarks="
-            + self.pos_args[1]
-            + " --statistics --perf_level=3 --db="
-            + db_path
-            + opt_args_str
-        )
-        self.assertEqual(experiment_command, expected_command)
-
-
-class TestDBBenchRunner(unittest.TestCase):
-    def setUp(self):
-        # Note: the db_bench binary should be present in the rocksdb/ directory
-        self.pos_args = [
-            "./../../db_bench",
-            "overwrite",
-            "use_existing_db=true",
-            "duration=20",
-        ]
-        self.bench_runner = DBBenchRunner(self.pos_args)
-        this_path = os.path.abspath(os.path.dirname(__file__))
-        options_path = os.path.join(this_path, "input_files/OPTIONS-000005")
-        self.db_options = DatabaseOptions(options_path)
-
-    def test_experiment_output(self):
-        update_dict = {"bloom_bits": {NO_COL_FAMILY: 2}}
-        self.db_options.update_options(update_dict)
-        db_path = "/dev/shm"
-        data_sources, throughput = self.bench_runner.run_experiment(
-            self.db_options, db_path
-        )
-        self.assertEqual(
-            data_sources[DataSource.Type.DB_OPTIONS][0].type, DataSource.Type.DB_OPTIONS
-        )
-        self.assertEqual(data_sources[DataSource.Type.LOG][0].type, DataSource.Type.LOG)
-        self.assertEqual(len(data_sources[DataSource.Type.TIME_SERIES]), 2)
-        self.assertEqual(
-            data_sources[DataSource.Type.TIME_SERIES][0].type,
-            DataSource.Type.TIME_SERIES,
-        )
-        self.assertEqual(
-            data_sources[DataSource.Type.TIME_SERIES][1].type,
-            DataSource.Type.TIME_SERIES,
-        )
-        self.assertEqual(data_sources[DataSource.Type.TIME_SERIES][1].stats_freq_sec, 0)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/vendor/rocksdb/tools/advisor/test/test_db_log_parser.py

@@ -1,96 +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 os
-import unittest
-
-from advisor.db_log_parser import DatabaseLogs, Log, NO_COL_FAMILY
-from advisor.rule_parser import Condition, LogCondition
-
-
-class TestLog(unittest.TestCase):
-    def setUp(self):
-        self.column_families = ["default", "col_fam_A"]
-
-    def test_get_column_family(self):
-        test_log = (
-            "2018/05/25-14:34:21.047233 7f82ba72e700 [db/flush_job.cc:371] "
-            + "[col_fam_A] [JOB 44] Level-0 flush table #84: 1890780 bytes OK"
-        )
-        db_log = Log(test_log, self.column_families)
-        self.assertEqual("col_fam_A", db_log.get_column_family())
-
-        test_log = (
-            "2018/05/25-14:34:21.047233 7f82ba72e700 [db/flush_job.cc:371] "
-            + "[JOB 44] Level-0 flush table #84: 1890780 bytes OK"
-        )
-        db_log = Log(test_log, self.column_families)
-        db_log.append_message("[default] some remaining part of log")
-        self.assertEqual(NO_COL_FAMILY, db_log.get_column_family())
-
-    def test_get_methods(self):
-        hr_time = "2018/05/25-14:30:25.491635"
-        context = "7f82ba72e700"
-        message = (
-            "[db/flush_job.cc:331] [default] [JOB 10] Level-0 flush table "
-            + "#23: started"
-        )
-        test_log = hr_time + " " + context + " " + message
-        db_log = Log(test_log, self.column_families)
-        self.assertEqual(db_log.get_message(), message)
-        remaining_message = "[col_fam_A] some more logs"
-        db_log.append_message(remaining_message)
-        self.assertEqual(db_log.get_human_readable_time(), "2018/05/25-14:30:25.491635")
-        self.assertEqual(db_log.get_context(), "7f82ba72e700")
-        self.assertEqual(db_log.get_timestamp(), 1527258625)
-        self.assertEqual(db_log.get_message(), str(message + "\n" + remaining_message))
-
-    def test_is_new_log(self):
-        new_log = "2018/05/25-14:34:21.047233 context random new log"
-        remaining_log = "2018/05/25 not really a new log"
-        self.assertTrue(Log.is_new_log(new_log))
-        self.assertFalse(Log.is_new_log(remaining_log))
-
-
-class TestDatabaseLogs(unittest.TestCase):
-    def test_check_and_trigger_conditions(self):
-        this_path = os.path.abspath(os.path.dirname(__file__))
-        logs_path_prefix = os.path.join(this_path, "input_files/LOG-0")
-        column_families = ["default", "col-fam-A", "col-fam-B"]
-        db_logs = DatabaseLogs(logs_path_prefix, column_families)
-        # matches, has 2 col_fams
-        condition1 = LogCondition.create(Condition("cond-A"))
-        condition1.set_parameter("regex", "random log message")
-        # matches, multiple lines message
-        condition2 = LogCondition.create(Condition("cond-B"))
-        condition2.set_parameter("regex", "continuing on next line")
-        # does not match
-        condition3 = LogCondition.create(Condition("cond-C"))
-        condition3.set_parameter("regex", "this should match no log")
-        db_logs.check_and_trigger_conditions([condition1, condition2, condition3])
-        cond1_trigger = condition1.get_trigger()
-        self.assertEqual(2, len(cond1_trigger.keys()))
-        self.assertSetEqual({"col-fam-A", NO_COL_FAMILY}, set(cond1_trigger.keys()))
-        self.assertEqual(2, len(cond1_trigger["col-fam-A"]))
-        messages = [
-            "[db/db_impl.cc:563] [col-fam-A] random log message for testing",
-            "[db/db_impl.cc:653] [col-fam-A] another random log message",
-        ]
-        self.assertIn(cond1_trigger["col-fam-A"][0].get_message(), messages)
-        self.assertIn(cond1_trigger["col-fam-A"][1].get_message(), messages)
-        self.assertEqual(1, len(cond1_trigger[NO_COL_FAMILY]))
-        self.assertEqual(
-            cond1_trigger[NO_COL_FAMILY][0].get_message(),
-            "[db/db_impl.cc:331] [unknown] random log message no column family",
-        )
-        cond2_trigger = condition2.get_trigger()
-        self.assertEqual(["col-fam-B"], list(cond2_trigger.keys()))
-        self.assertEqual(1, len(cond2_trigger["col-fam-B"]))
-        self.assertEqual(
-            cond2_trigger["col-fam-B"][0].get_message(),
-            "[db/db_impl.cc:234] [col-fam-B] log continuing on next line\n"
-            + "remaining part of the log",
-        )
-        self.assertIsNone(condition3.get_trigger())

package/vendor/rocksdb/tools/advisor/test/test_db_options_parser.py

@@ -1,214 +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 os
-import unittest
-
-from advisor.db_log_parser import NO_COL_FAMILY
-from advisor.db_options_parser import DatabaseOptions
-from advisor.rule_parser import Condition, OptionCondition
-
-
-class TestDatabaseOptions(unittest.TestCase):
-    def setUp(self):
-        self.this_path = os.path.abspath(os.path.dirname(__file__))
-        self.og_options = os.path.join(self.this_path, "input_files/OPTIONS-000005")
-        misc_options = ["bloom_bits = 4", "rate_limiter_bytes_per_sec = 1024000"]
-        # create the options object
-        self.db_options = DatabaseOptions(self.og_options, misc_options)
-        # perform clean-up before running tests
-        self.generated_options = os.path.join(
-            self.this_path, "../temp/OPTIONS_testing.tmp"
-        )
-        if os.path.isfile(self.generated_options):
-            os.remove(self.generated_options)
-
-    def test_get_options_diff(self):
-        old_opt = {
-            "DBOptions.stats_dump_freq_sec": {NO_COL_FAMILY: "20"},
-            "CFOptions.write_buffer_size": {
-                "default": "1024000",
-                "col_fam_A": "128000",
-                "col_fam_B": "128000000",
-            },
-            "DBOptions.use_fsync": {NO_COL_FAMILY: "true"},
-            "DBOptions.max_log_file_size": {NO_COL_FAMILY: "128000000"},
-        }
-        new_opt = {
-            "bloom_bits": {NO_COL_FAMILY: "4"},
-            "CFOptions.write_buffer_size": {
-                "default": "128000000",
-                "col_fam_A": "128000",
-                "col_fam_C": "128000000",
-            },
-            "DBOptions.use_fsync": {NO_COL_FAMILY: "true"},
-            "DBOptions.max_log_file_size": {NO_COL_FAMILY: "0"},
-        }
-        diff = DatabaseOptions.get_options_diff(old_opt, new_opt)
-
-        expected_diff = {
-            "DBOptions.stats_dump_freq_sec": {NO_COL_FAMILY: ("20", None)},
-            "bloom_bits": {NO_COL_FAMILY: (None, "4")},
-            "CFOptions.write_buffer_size": {
-                "default": ("1024000", "128000000"),
-                "col_fam_B": ("128000000", None),
-                "col_fam_C": (None, "128000000"),
-            },
-            "DBOptions.max_log_file_size": {NO_COL_FAMILY: ("128000000", "0")},
-        }
-        self.assertDictEqual(diff, expected_diff)
-
-    def test_is_misc_option(self):
-        self.assertTrue(DatabaseOptions.is_misc_option("bloom_bits"))
-        self.assertFalse(
-            DatabaseOptions.is_misc_option("DBOptions.stats_dump_freq_sec")
-        )
-
-    def test_set_up(self):
-        options = self.db_options.get_all_options()
-        self.assertEqual(22, len(options.keys()))
-        expected_misc_options = {
-            "bloom_bits": "4",
-            "rate_limiter_bytes_per_sec": "1024000",
-        }
-        self.assertDictEqual(expected_misc_options, self.db_options.get_misc_options())
-        self.assertListEqual(
-            ["default", "col_fam_A"], self.db_options.get_column_families()
-        )
-
-    def test_get_options(self):
-        opt_to_get = [
-            "DBOptions.manual_wal_flush",
-            "DBOptions.db_write_buffer_size",
-            "bloom_bits",
-            "CFOptions.compaction_filter_factory",
-            "CFOptions.num_levels",
-            "rate_limiter_bytes_per_sec",
-            "TableOptions.BlockBasedTable.block_align",
-            "random_option",
-        ]
-        options = self.db_options.get_options(opt_to_get)
-        expected_options = {
-            "DBOptions.manual_wal_flush": {NO_COL_FAMILY: "false"},
-            "DBOptions.db_write_buffer_size": {NO_COL_FAMILY: "0"},
-            "bloom_bits": {NO_COL_FAMILY: "4"},
-            "CFOptions.compaction_filter_factory": {
-                "default": "nullptr",
-                "col_fam_A": "nullptr",
-            },
-            "CFOptions.num_levels": {"default": "7", "col_fam_A": "5"},
-            "rate_limiter_bytes_per_sec": {NO_COL_FAMILY: "1024000"},
-            "TableOptions.BlockBasedTable.block_align": {
-                "default": "false",
-                "col_fam_A": "true",
-            },
-        }
-        self.assertDictEqual(expected_options, options)
-
-    def test_update_options(self):
-        # add new, update old, set old
-        # before updating
-        expected_old_opts = {
-            "DBOptions.db_log_dir": {NO_COL_FAMILY: None},
-            "DBOptions.manual_wal_flush": {NO_COL_FAMILY: "false"},
-            "bloom_bits": {NO_COL_FAMILY: "4"},
-            "CFOptions.num_levels": {"default": "7", "col_fam_A": "5"},
-            "TableOptions.BlockBasedTable.block_restart_interval": {"col_fam_A": "16"},
-        }
-        get_opts = list(expected_old_opts.keys())
-        options = self.db_options.get_options(get_opts)
-        self.assertEqual(expected_old_opts, options)
-        # after updating options
-        update_opts = {
-            "DBOptions.db_log_dir": {NO_COL_FAMILY: "/dev/shm"},
-            "DBOptions.manual_wal_flush": {NO_COL_FAMILY: "true"},
-            "bloom_bits": {NO_COL_FAMILY: "2"},
-            "CFOptions.num_levels": {"col_fam_A": "7"},
-            "TableOptions.BlockBasedTable.block_restart_interval": {"default": "32"},
-            "random_misc_option": {NO_COL_FAMILY: "something"},
-        }
-        self.db_options.update_options(update_opts)
-        update_opts["CFOptions.num_levels"]["default"] = "7"
-        update_opts["TableOptions.BlockBasedTable.block_restart_interval"] = {
-            "default": "32",
-            "col_fam_A": "16",
-        }
-        get_opts.append("random_misc_option")
-        options = self.db_options.get_options(get_opts)
-        self.assertDictEqual(update_opts, options)
-        expected_misc_options = {
-            "bloom_bits": "2",
-            "rate_limiter_bytes_per_sec": "1024000",
-            "random_misc_option": "something",
-        }
-        self.assertDictEqual(expected_misc_options, self.db_options.get_misc_options())
-
-    def test_generate_options_config(self):
-        # make sure file does not exist from before
-        self.assertFalse(os.path.isfile(self.generated_options))
-        self.db_options.generate_options_config("testing")
-        self.assertTrue(os.path.isfile(self.generated_options))
-
-    def test_check_and_trigger_conditions(self):
-        # options only from CFOptions
-        # setup the OptionCondition objects to check and trigger
-        update_dict = {
-            "CFOptions.level0_file_num_compaction_trigger": {"col_fam_A": "4"},
-            "CFOptions.max_bytes_for_level_base": {"col_fam_A": "10"},
-        }
-        self.db_options.update_options(update_dict)
-        cond1 = Condition("opt-cond-1")
-        cond1 = OptionCondition.create(cond1)
-        cond1.set_parameter(
-            "options",
-            [
-                "CFOptions.level0_file_num_compaction_trigger",
-                "TableOptions.BlockBasedTable.block_restart_interval",
-                "CFOptions.max_bytes_for_level_base",
-            ],
-        )
-        cond1.set_parameter(
-            "evaluate", "int(options[0])*int(options[1])-int(options[2])>=0"
-        )
-        # only DBOptions
-        cond2 = Condition("opt-cond-2")
-        cond2 = OptionCondition.create(cond2)
-        cond2.set_parameter(
-            "options",
-            [
-                "DBOptions.db_write_buffer_size",
-                "bloom_bits",
-                "rate_limiter_bytes_per_sec",
-            ],
-        )
-        cond2.set_parameter(
-            "evaluate", "(int(options[2]) * int(options[1]) * int(options[0]))==0"
-        )
-        # mix of CFOptions and DBOptions
-        cond3 = Condition("opt-cond-3")
-        cond3 = OptionCondition.create(cond3)
-        cond3.set_parameter(
-            "options",
-            [
-                "DBOptions.db_write_buffer_size",  # 0
-                "CFOptions.num_levels",  # 5, 7
-                "bloom_bits",  # 4
-            ],
-        )
-        cond3.set_parameter(
-            "evaluate", "int(options[2])*int(options[0])+int(options[1])>6"
-        )
-        self.db_options.check_and_trigger_conditions([cond1, cond2, cond3])
-
-        cond1_trigger = {"col_fam_A": ["4", "16", "10"]}
-        self.assertDictEqual(cond1_trigger, cond1.get_trigger())
-        cond2_trigger = {NO_COL_FAMILY: ["0", "4", "1024000"]}
-        self.assertDictEqual(cond2_trigger, cond2.get_trigger())
-        cond3_trigger = {"default": ["0", "7", "4"]}
-        self.assertDictEqual(cond3_trigger, cond3.get_trigger())
-
-
-if __name__ == "__main__":
-    unittest.main()

package/vendor/rocksdb/tools/advisor/test/test_db_stats_fetcher.py

@@ -1,121 +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 os
-import time
-import unittest
-from unittest.mock import MagicMock
-
-from advisor.db_stats_fetcher import DatabasePerfContext, LogStatsParser
-from advisor.db_timeseries_parser import NO_ENTITY
-from advisor.rule_parser import Condition, TimeSeriesCondition
-
-
-class TestLogStatsParser(unittest.TestCase):
-    def setUp(self):
-        this_path = os.path.abspath(os.path.dirname(__file__))
-        stats_file = os.path.join(this_path, "input_files/log_stats_parser_keys_ts")
-        # populate the keys_ts dictionary of LogStatsParser
-        self.stats_dict = {NO_ENTITY: {}}
-        with open(stats_file, "r") as fp:
-            for line in fp:
-                stat_name = line.split(":")[0].strip()
-                self.stats_dict[NO_ENTITY][stat_name] = {}
-                token_list = line.split(":")[1].strip().split(",")
-                for token in token_list:
-                    timestamp = int(token.split()[0])
-                    value = float(token.split()[1])
-                    self.stats_dict[NO_ENTITY][stat_name][timestamp] = value
-        self.log_stats_parser = LogStatsParser("dummy_log_file", 20)
-        self.log_stats_parser.keys_ts = self.stats_dict
-
-    def test_check_and_trigger_conditions_bursty(self):
-        # mock fetch_timeseries() because 'keys_ts' has been pre-populated
-        self.log_stats_parser.fetch_timeseries = MagicMock()
-        # condition: bursty
-        cond1 = Condition("cond-1")
-        cond1 = TimeSeriesCondition.create(cond1)
-        cond1.set_parameter("keys", "rocksdb.db.get.micros.p50")
-        cond1.set_parameter("behavior", "bursty")
-        cond1.set_parameter("window_sec", 40)
-        cond1.set_parameter("rate_threshold", 0)
-        self.log_stats_parser.check_and_trigger_conditions([cond1])
-        expected_cond_trigger = {NO_ENTITY: {1530896440: 0.9767546362322214}}
-        self.assertDictEqual(expected_cond_trigger, cond1.get_trigger())
-        # ensure that fetch_timeseries() was called once
-        self.log_stats_parser.fetch_timeseries.assert_called_once()
-
-    def test_check_and_trigger_conditions_eval_agg(self):
-        # mock fetch_timeseries() because 'keys_ts' has been pre-populated
-        self.log_stats_parser.fetch_timeseries = MagicMock()
-        # condition: evaluate_expression
-        cond1 = Condition("cond-1")
-        cond1 = TimeSeriesCondition.create(cond1)
-        cond1.set_parameter("keys", "rocksdb.db.get.micros.p50")
-        cond1.set_parameter("behavior", "evaluate_expression")
-        keys = ["rocksdb.manifest.file.sync.micros.p99", "rocksdb.db.get.micros.p50"]
-        cond1.set_parameter("keys", keys)
-        cond1.set_parameter("aggregation_op", "latest")
-        # condition evaluates to FALSE
-        cond1.set_parameter("evaluate", "keys[0]-(keys[1]*100)>200")
-        self.log_stats_parser.check_and_trigger_conditions([cond1])
-        expected_cond_trigger = {NO_ENTITY: [1792.0, 15.9638]}
-        self.assertIsNone(cond1.get_trigger())
-        # condition evaluates to TRUE
-        cond1.set_parameter("evaluate", "keys[0]-(keys[1]*100)<200")
-        self.log_stats_parser.check_and_trigger_conditions([cond1])
-        expected_cond_trigger = {NO_ENTITY: [1792.0, 15.9638]}
-        self.assertDictEqual(expected_cond_trigger, cond1.get_trigger())
-        # ensure that fetch_timeseries() was called
-        self.log_stats_parser.fetch_timeseries.assert_called()
-
-    def test_check_and_trigger_conditions_eval(self):
-        # mock fetch_timeseries() because 'keys_ts' has been pre-populated
-        self.log_stats_parser.fetch_timeseries = MagicMock()
-        # condition: evaluate_expression
-        cond1 = Condition("cond-1")
-        cond1 = TimeSeriesCondition.create(cond1)
-        cond1.set_parameter("keys", "rocksdb.db.get.micros.p50")
-        cond1.set_parameter("behavior", "evaluate_expression")
-        keys = ["rocksdb.manifest.file.sync.micros.p99", "rocksdb.db.get.micros.p50"]
-        cond1.set_parameter("keys", keys)
-        cond1.set_parameter("evaluate", "keys[0]-(keys[1]*100)>500")
-        self.log_stats_parser.check_and_trigger_conditions([cond1])
-        expected_trigger = {
-            NO_ENTITY: {
-                1530896414: [9938.0, 16.31508],
-                1530896440: [9938.0, 16.346602],
-                1530896466: [9938.0, 16.284669],
-                1530896492: [9938.0, 16.16005],
-            }
-        }
-        self.assertDictEqual(expected_trigger, cond1.get_trigger())
-        self.log_stats_parser.fetch_timeseries.assert_called_once()
-
-
-class TestDatabasePerfContext(unittest.TestCase):
-    def test_unaccumulate_metrics(self):
-        perf_dict = {
-            "user_key_comparison_count": 675903942,
-            "block_cache_hit_count": 830086,
-        }
-        timestamp = int(time.time())
-        perf_ts = {}
-        for key in perf_dict:
-            perf_ts[key] = {}
-            start_val = perf_dict[key]
-            for ix in range(5):
-                perf_ts[key][timestamp + (ix * 10)] = start_val + (2 * ix * ix)
-        db_perf_context = DatabasePerfContext(perf_ts, 10, True)
-        timestamps = [timestamp + (ix * 10) for ix in range(1, 5, 1)]
-        values = [val for val in range(2, 15, 4)]
-        inner_dict = {timestamps[ix]: values[ix] for ix in range(4)}
-        expected_keys_ts = {
-            NO_ENTITY: {
-                "user_key_comparison_count": inner_dict,
-                "block_cache_hit_count": inner_dict,
-            }
-        }
-        self.assertDictEqual(expected_keys_ts, db_perf_context.keys_ts)