Ejemplo n.º 1
0
def test_projects_one_histogram(store: RedisRealtimeMetricsStore,
                                redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.hset("symbolicate_event_low_priority:duration:10:42:111:0",
                       0, 123)

    candidates = store.projects()
    assert list(candidates) == [42]
Ejemplo n.º 2
0
def test_projects_negative_timestamp(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:-111", 0)

    candidates = store.projects()
    assert list(candidates) == [42]
Ejemplo n.º 3
0
def test_projects_mixed_buckets(store: RedisRealtimeMetricsStore,
                                redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:111", 0)
    redis_cluster.set("symbolicate_event_low_priority:counter:5:53:111", 0)

    candidates = store.projects()
    assert list(candidates) == [42]
Ejemplo n.º 4
0
def test_remove_projects_from_lpq_backing_off_reremoving(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set(f"{store._backoff_key_prefix()}:1", 1)

    removed = store.remove_projects_from_lpq({1})
    assert not removed
Ejemplo n.º 5
0
def test_get_counts_for_projects_with_gap(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    store._counter_time_window = 40
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:110", 3)
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:150", 17)

    buckets = store.get_counts_for_project(project_id=42, timestamp=154)

    assert buckets.total_count() == 20

    assert buckets.counts[-1] == 17
    assert buckets.counts[-2] == 0
    assert buckets.counts[-3] == 0
    assert buckets.counts[-4] == 0
    assert buckets.counts[-5] == 3
Ejemplo n.º 6
0
def test_get_lpq_projects_empty(store: RedisRealtimeMetricsStore,
                                redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.sadd("store.symbolicate-event-lpq-selected", 1)
    redis_cluster.srem("store.symbolicate-event-lpq-selected", 1)

    in_lpq = store.get_lpq_projects()
    assert in_lpq == set()
Ejemplo n.º 7
0
def test_add_project_to_lpq_backing_off_adding(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set(f"{store._backoff_key_prefix()}:1", 1)

    added = store.add_project_to_lpq(1)
    assert not added
Ejemplo n.º 8
0
def test_add_project_to_lpq_filled(store: RedisRealtimeMetricsStore,
                                   redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.sadd("store.symbolicate-event-lpq-selected", 11)

    added = store.add_project_to_lpq(1)
    assert added
    in_lpq = redis_cluster.smembers("store.symbolicate-event-lpq-selected")
    assert in_lpq == {"1", "11"}
Ejemplo n.º 9
0
def test_get_durations_for_project_no_matching_keys(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.hset("symbolicate_event_low_priority:histogram:10:53:111", 0,
                       123)

    counts = store.get_durations_for_project(42)
    assert list(counts) == []
Ejemplo n.º 10
0
def test_remove_projects_from_lpq_unset(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    removed = store.remove_projects_from_lpq({1})
    assert removed == 0

    remaining = redis_cluster.smembers("store.symbolicate-event-lpq-selected")
    assert remaining == set()
Ejemplo n.º 11
0
def test_get_durations_for_project_unset(
        store: RedisRealtimeMetricsStore) -> None:
    durations = store.get_durations_for_project(project_id=42, timestamp=113)

    assert len(durations.histograms) == 13

    for hist in durations.histograms:
        assert hist.total_count() == 0
Ejemplo n.º 12
0
def test_get_counts_for_project_no_matching_keys(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:53:111", 0)

    counts = store.get_counts_for_project(42, 113)

    assert list(counts) == [BucketedCount(timestamp=110, count=0)]
Ejemplo n.º 13
0
def test_get_counts_for_project_missing_project(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:53:111", 0)

    buckets = store.get_counts_for_project(project_id=42, timestamp=113)

    assert buckets.total_count() == 0
Ejemplo n.º 14
0
def test_get_counts_for_project_negative_count(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:111", -10)

    counts = store.get_counts_for_project(42)
    assert list(counts) == [
        BucketedCount(timestamp=111, count=-10),
    ]
Ejemplo n.º 15
0
def test_projects_multiple_metric_types(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:111", 0)
    redis_cluster.hset("symbolicate_event_low_priority:duration:10:53:111:20",
                       20, 456)

    candidates = store.projects()
    assert list(candidates) == [42, 53]
Ejemplo n.º 16
0
def test_get_counts_for_project_different_bucket_sizes(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:110", 1)
    redis_cluster.set("symbolicate_event_low_priority:counter:5:42:110", 2)

    buckets = store.get_counts_for_project(project_id=42, timestamp=113)

    assert buckets.total_count() == 1
Ejemplo n.º 17
0
def test_get_counts_for_project_unset(
        store: RedisRealtimeMetricsStore) -> None:
    buckets = store.get_counts_for_project(project_id=42, timestamp=113)

    # It is impossible to specify the last possible time in the current bucket, so we always
    # still fall back to 13 buckets to cover the time window.
    assert len(buckets.counts) == 13

    assert buckets.total_count() == 0
Ejemplo n.º 18
0
def test_invalid_config() -> None:
    invalid_config: Dict[str, Any] = {
        "cluster": "default",
        "counter_bucket_size": 0,
        "counter_time_window": -1,
        "duration_bucket_size": -10,
        "duration_time_window": 0,
        "backoff_timer": -100,
    }
    RedisRealtimeMetricsStore(**invalid_config)
Ejemplo n.º 19
0
def test_projects_empty(store: RedisRealtimeMetricsStore,
                        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set(
        "symbolicate_event_low_priority:counter:10:42:111",
        0,
    )
    redis_cluster.delete("symbolicate_event_low_priority:counter:10:42:111")

    candidates = store.projects()
    assert list(candidates) == []
Ejemplo n.º 20
0
def test_get_counts_for_project_empty(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set(
        "symbolicate_event_low_priority:counter:10:42:111",
        0,
    )
    redis_cluster.delete("symbolicate_event_low_priority:counter:10:42:111")

    counts = store.get_counts_for_project(42)
    assert list(counts) == []
Ejemplo n.º 21
0
def test_get_durations_for_project_missing_project(
    store: RedisRealtimeMetricsStore,
    redis_cluster: redis._RedisCluster,
) -> None:
    redis_cluster.hset("symbolicate_event_low_priority:duration:10:53:111", 0,
                       123)

    durations = store.get_durations_for_project(project_id=42, timestamp=113)

    for hist in durations.histograms:
        assert hist.total_count() == 0
Ejemplo n.º 22
0
def test_get_durations_for_project_multi_metric(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:111", 0)
    redis_cluster.hset("symbolicate_event_low_priority:histogram:10:42:222", 0,
                       123)

    counts = store.get_durations_for_project(42)
    assert list(counts) == [
        DurationHistogram(timestamp=222, histogram=BucketedDurations({0: 123}))
    ]
Ejemplo n.º 23
0
def test_get_counts_for_project_multi_metric(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:111", 0)
    redis_cluster.hset("symbolicate_event_low_priority:histogram:10:42:222:0",
                       0, 123)

    counts = store.get_counts_for_project(42)
    assert list(counts) == [
        BucketedCount(timestamp=111, count=0),
    ]
Ejemplo n.º 24
0
def test_get_counts_for_project_different_buckets(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set("symbolicate_event_low_priority:counter:10:42:110", 0)
    redis_cluster.set("symbolicate_event_low_priority:counter:5:42:110", 0)

    counts = store.get_counts_for_project(42, 113)

    assert list(counts) == [
        BucketedCount(timestamp=110, count=0),
    ]
Ejemplo n.º 25
0
def test_get_durations_for_project_unset(
        store: RedisRealtimeMetricsStore) -> None:
    durations = store.get_durations_for_project(42, 113)

    assert list(durations) == [
        DurationHistogram(timestamp=110,
                          histogram=BucketedDurations(empty_histogram()))
    ]

    store._duration_time_window = 20

    durations = store.get_durations_for_project(42, 113)

    assert list(durations) == [
        DurationHistogram(timestamp=90,
                          histogram=BucketedDurations(empty_histogram())),
        DurationHistogram(timestamp=100,
                          histogram=BucketedDurations(empty_histogram())),
        DurationHistogram(timestamp=110,
                          histogram=BucketedDurations(empty_histogram())),
    ]
Ejemplo n.º 26
0
def test_get_durations_for_project_different_buckets(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.hset("symbolicate_event_low_priority:histogram:10:42:111", 0,
                       123)
    redis_cluster.hset("symbolicate_event_low_priority:histogram:5:42:111", 20,
                       456)

    counts = store.get_durations_for_project(42)
    assert list(counts) == [
        DurationHistogram(timestamp=111, histogram=BucketedDurations({0: 123}))
    ]
Ejemplo n.º 27
0
def test_get_durations_for_project_no_matching_keys(
    store: RedisRealtimeMetricsStore,
    redis_cluster: redis._RedisCluster,
) -> None:
    redis_cluster.hset("symbolicate_event_low_priority:duration:10:53:111", 0,
                       123)

    durations = store.get_durations_for_project(42, 113)

    assert list(durations) == [
        DurationHistogram(timestamp=110,
                          histogram=BucketedDurations(empty_histogram()))
    ]
Ejemplo n.º 28
0
def test_get_counts_for_project_empty(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    redis_cluster.set(
        "symbolicate_event_low_priority:counter:10:42:111",
        0,
    )
    redis_cluster.delete("symbolicate_event_low_priority:counter:10:42:111")

    counts = store.get_counts_for_project(42, 113)

    assert list(counts) == [BucketedCount(timestamp=110, count=0)]

    store._counter_time_window = 20

    counts = store.get_counts_for_project(42, 113)

    assert list(counts) == [
        BucketedCount(timestamp=90, count=0),
        BucketedCount(timestamp=100, count=0),
        BucketedCount(timestamp=110, count=0),
    ]
Ejemplo n.º 29
0
def test_get_durations_for_project_different_bucket_sizes(
    store: RedisRealtimeMetricsStore,
    redis_cluster: redis._RedisCluster,
) -> None:
    redis_cluster.hset("symbolicate_event_low_priority:duration:10:42:110", 0,
                       123)
    redis_cluster.hset("symbolicate_event_low_priority:duration:5:42:110", 20,
                       456)

    durations = store.get_durations_for_project(42, 113)

    total = sum(h.total_count() for h in durations.histograms)

    assert total == 123
Ejemplo n.º 30
0
def test_get_durations_for_projects_with_gap(
        store: RedisRealtimeMetricsStore,
        redis_cluster: redis._RedisCluster) -> None:
    store._duration_time_window = 40
    redis_cluster.hset("symbolicate_event_low_priority:duration:10:42:110", 20,
                       3)
    redis_cluster.hset("symbolicate_event_low_priority:duration:10:42:150", 30,
                       17)

    hist1 = empty_histogram()
    hist1[20] = 3

    hist2 = empty_histogram()
    hist2[30] = 17

    durations = store.get_durations_for_project(42, 154)

    assert list(durations) == [
        DurationHistogram(timestamp=110, histogram=hist1),
        DurationHistogram(timestamp=120, histogram=empty_histogram()),
        DurationHistogram(timestamp=130, histogram=empty_histogram()),
        DurationHistogram(timestamp=140, histogram=empty_histogram()),
        DurationHistogram(timestamp=150, histogram=hist2),
    ]