def gen_measurements(day):
"""
Generate measurements that are random but distribution changs based on the day
"""
return {
"fp": {"value": random_normal(1250 - 50 * day, 200, 500)},
"fcp": {"value": random_normal(1250 - 50 * day, 200, 500)},
"lcp": {"value": random_normal(2800 - 50 * day, 400, 2000)},
"fid": {"value": random_normal(5 - 0.125 * day, 2, 1)},
}
def gen_measurements(full_duration):
duration_ms = full_duration * 1000.0
"""
Generate measurements that are random but based on the full duration
"""
return {
"fp": {
"value": duration_ms - random_normal(400, 100, 100)
},
"fcp": {
"value": duration_ms - random_normal(400, 100, 100)
},
"lcp": {
"value": duration_ms + random_normal(400, 100, 100)
},
"fid": {
"value": random_normal(5, 2, 1)
},
}
def gen_frontend_duration(day, quick):
"""
Generates the length of the front-end transaction based on our config,
the day, and some randomness
"""
config = get_config(quick)
DAY_DURATION_IMPACT = config["DAY_DURATION_IMPACT"]
MAX_DAYS = config["MAX_DAYS"]
BASE_FRONTEND_DURATION = config["BASE_FRONTEND_DURATION"]
MIN_FRONTEND_DURATION = config["MIN_FRONTEND_DURATION"]
DURATION_SIGMA = config["DURATION_SIGMA"]
day_weight = DAY_DURATION_IMPACT * day / MAX_DAYS
return (random_normal(BASE_FRONTEND_DURATION - day_weight, DURATION_SIGMA,
MIN_FRONTEND_DURATION) / 1000.0)
def gen_measurements(full_duration):
duration_ms = full_duration * 1000.0
"""
Generate measurements that are random but based on the full duration
"""
return {
"fp": {
"value": duration_ms * random.uniform(0.8, 0.95)
},
"fcp": {
"value": duration_ms * random.uniform(0.8, 0.95)
},
"lcp": {
"value": duration_ms * random.uniform(1.05, 1.2)
},
"fid": {
"value": random_normal(5, 2, 1)
},
}
def populate_connected_event_scenario_2(react_project: Project,
python_project: Project,
quick=False):
"""
This function populates a set of two related events with the same trace id:
- Front-end transaction
- Back-end transaction
Occurrance times and durations are randomized
"""
react_transaction = get_event_from_file("scen2/react_transaction.json")
python_transaction = get_event_from_file("scen2/python_transaction.json")
log_extra = {
"organization_slug": react_project.organization.slug,
"quick": quick,
}
logger.info("populate_connected_event_scenario_2.start", extra=log_extra)
for (timestamp, day) in iter_timestamps(2, quick):
transaction_user = generate_user(quick)
trace_id = uuid4().hex
release = get_release_from_time(react_project.organization_id,
timestamp)
release_sha = release.version
old_span_id = react_transaction["contexts"]["trace"]["span_id"]
frontend_root_span_id = uuid4().hex[:16]
frontend_duration = gen_frontend_duration(day, quick)
frontend_trace = {
"trace_id": trace_id,
"span_id": frontend_root_span_id,
}
# React transaction
local_event = copy.deepcopy(react_transaction)
local_event.update(
project=react_project,
platform=react_project.platform,
event_id=uuid4().hex,
user=transaction_user,
release=release_sha,
timestamp=timestamp,
# start_timestamp decreases based on day so that there's a trend
start_timestamp=timestamp - timedelta(seconds=frontend_duration),
measurements=gen_measurements(frontend_duration),
)
update_context(local_event, frontend_trace)
fix_transaction_event(local_event, old_span_id)
safe_send_event(local_event, quick)
# note picking the 0th span is arbitrary
backend_parent_id = local_event["spans"][0]["span_id"]
# python transaction
old_span_id = python_transaction["contexts"]["trace"]["span_id"]
backend_duration = frontend_duration - random_normal(0.3, 0.1, 0.1)
backend_trace = {
"trace_id": trace_id,
"span_id": uuid4().hex[:16],
"parent_span_id": backend_parent_id,
}
local_event = copy.deepcopy(python_transaction)
local_event.update(
project=python_project,
platform=python_project.platform,
timestamp=timestamp,
start_timestamp=timestamp - timedelta(seconds=backend_duration),
user=transaction_user,
release=release_sha,
)
update_context(local_event, backend_trace)
fix_transaction_event(local_event, old_span_id)
safe_send_event(local_event, quick)
logger.info("populate_connected_event_scenario_2.finished",
extra=log_extra)
def populate_connected_event_scenario_1(react_project: Project, python_project: Project):
"""
This function populates a set of four related events with the same trace id:
- Front-end transaction
- Front-end error
- Back-end transaction
- Back-end error
Occurrance times and durations are randomized
"""
react_transaction = get_event_from_file("src/sentry/demo/data/react_transaction_1.json")
react_error = get_event_from_file("src/sentry/demo/data/react_error_1.json")
python_transaction = get_event_from_file("src/sentry/demo/data/python_transaction_1.json")
python_error = get_event_from_file("src/sentry/demo/data/python_error_1.json")
for day in range(MAX_DAYS):
for hour in range(24):
base = distribution_v1(hour)
# determine the number of events we want in this hour
num_events = int((BASE_OFFSET + SCALE_FACTOR * base) * random.uniform(0.6, 1.0))
for i in range(num_events):
# pick the minutes randomly (which means events will sent be out of order)
minute = random.randint(0, 60)
timestamp = timezone.now() - timedelta(days=day, hours=hour, minutes=minute)
timestamp = timestamp.replace(tzinfo=pytz.utc)
transaction_user = generate_user()
trace_id = uuid4().hex
old_span_id = react_transaction["contexts"]["trace"]["span_id"]
frontend_root_span_id = uuid4().hex[:16]
frontend_duration = random_normal(2000 - 50 * day, 250, 1000) / 1000.0
frontend_context = {
"trace": {
"type": "trace",
"trace_id": trace_id,
"span_id": frontend_root_span_id,
}
}
# React transaction
local_event = copy.deepcopy(react_transaction)
local_event.update(
project=react_project,
platform=react_project.platform,
event_id=uuid4().hex,
user=transaction_user,
timestamp=timestamp,
# start_timestamp decreases based on day so that there's a trend
start_timestamp=timestamp - timedelta(seconds=frontend_duration),
measurements={
"fp": {"value": random_normal(1250 - 50 * day, 200, 500)},
"fcp": {"value": random_normal(1250 - 50 * day, 200, 500)},
"lcp": {"value": random_normal(2800 - 50 * day, 400, 2000)},
"fid": {"value": random_normal(5 - 0.125 * day, 2, 1)},
},
contexts=frontend_context,
)
fix_transaction_event(local_event, old_span_id)
safe_send_event(local_event)
# note picking the 0th span is arbitrary
backend_parent_id = local_event["spans"][0]["span_id"]
# React error
local_event = copy.deepcopy(react_error)
local_event.update(
project=react_project,
platform=react_project.platform,
timestamp=timestamp,
user=transaction_user,
contexts=frontend_context,
)
fix_error_event(local_event)
safe_send_event(local_event)
# python transaction
old_span_id = python_transaction["contexts"]["trace"]["span_id"]
backend_duration = random_normal(1500 + 50 * day, 250, 500)
backend_context = {
"trace": {
"type": "trace",
"trace_id": trace_id,
"span_id": uuid4().hex[:16],
"parent_span_id": backend_parent_id,
}
}
local_event = copy.deepcopy(python_transaction)
local_event.update(
project=python_project,
platform=python_project.platform,
timestamp=timestamp,
start_timestamp=timestamp - timedelta(milliseconds=backend_duration),
user=transaction_user,
contexts=backend_context,
)
fix_transaction_event(local_event, old_span_id)
safe_send_event(local_event)
# python error
local_event = copy.deepcopy(python_error)
local_event.update(
project=python_project,
platform=python_project.platform,
timestamp=timestamp,
user=transaction_user,
contexts=backend_context,
)
fix_error_event(local_event)
safe_send_event(local_event)
def populate_connected_event_scenario_1(
react_project: Project, python_project: Project, quick=False
):
"""
This function populates a set of four related events with the same trace id:
- Front-end transaction
- Front-end error
- Back-end transaction
- Back-end error
Occurrance times and durations are randomized
"""
react_transaction = get_event_from_file("scen1/react_transaction.json")
react_error = get_event_from_file("scen1/react_error.json")
python_transaction = get_event_from_file("scen1/python_transaction.json")
python_error = get_event_from_file("scen1/python_error.json")
log_extra = {
"organization_slug": react_project.organization.slug,
"quick": quick,
}
logger.info("populate_connected_event_scenario_1.start", extra=log_extra)
for (timestamp, day) in iter_timestamps(1, quick):
transaction_user = generate_user(quick)
trace_id = uuid4().hex
release = get_release_from_time(react_project.organization_id, timestamp)
release_sha = release.version
old_span_id = react_transaction["contexts"]["trace"]["span_id"]
frontend_root_span_id = uuid4().hex[:16]
frontend_duration = random_normal(2000 - 50 * day, 250, 1000) / 1000.0
frontend_context = {
"trace": {
"type": "trace",
"trace_id": trace_id,
"span_id": frontend_root_span_id,
}
}
# React transaction
local_event = copy.deepcopy(react_transaction)
local_event.update(
project=react_project,
platform=react_project.platform,
event_id=uuid4().hex,
user=transaction_user,
release=release_sha,
timestamp=timestamp,
# start_timestamp decreases based on day so that there's a trend
start_timestamp=timestamp - timedelta(seconds=frontend_duration),
measurements=gen_measurements(day),
contexts=frontend_context,
)
fix_transaction_event(local_event, old_span_id)
safe_send_event(local_event, quick)
# note picking the 0th span is arbitrary
backend_parent_id = local_event["spans"][0]["span_id"]
# React error
local_event = copy.deepcopy(react_error)
local_event.update(
project=react_project,
platform=react_project.platform,
timestamp=timestamp,
user=transaction_user,
release=release_sha,
contexts=frontend_context,
)
fix_error_event(local_event, quick)
safe_send_event(local_event, quick)
# python transaction
old_span_id = python_transaction["contexts"]["trace"]["span_id"]
backend_duration = random_normal(1500 + 50 * day, 250, 500)
backend_context = {
"trace": {
"type": "trace",
"trace_id": trace_id,
"span_id": uuid4().hex[:16],
"parent_span_id": backend_parent_id,
}
}
local_event = copy.deepcopy(python_transaction)
local_event.update(
project=python_project,
platform=python_project.platform,
timestamp=timestamp,
start_timestamp=timestamp - timedelta(milliseconds=backend_duration),
user=transaction_user,
release=release_sha,
contexts=backend_context,
)
fix_transaction_event(local_event, old_span_id)
safe_send_event(local_event, quick)
# python error
local_event = copy.deepcopy(python_error)
local_event.update(
project=python_project,
platform=python_project.platform,
timestamp=timestamp,
user=transaction_user,
release=release_sha,
contexts=backend_context,
)
fix_error_event(local_event, quick)
safe_send_event(local_event, quick)
logger.info("populate_connected_event_scenario_1.finished", extra=log_extra)
def populate_connected_event_scenario_1(react_project: Project,
python_project: Project,
quick=False):
"""
This function populates a set of four related events with the same trace id:
- Front-end transaction
- Front-end error
- Back-end transaction
- Back-end error
Occurrance times and durations are randomized
"""
react_transaction = get_event_from_file("react_transaction_1.json")
react_error = get_event_from_file("react_error_1.json")
python_transaction = get_event_from_file("python_transaction_1.json")
python_error = get_event_from_file("python_error_1.json")
config = get_config(quick)
MAX_DAYS = config["MAX_DAYS"]
SCALE_FACTOR = config["SCALE_FACTOR"]
BASE_OFFSET = config["BASE_OFFSET"]
start_time = timezone.now() - timedelta(days=MAX_DAYS)
log_extra = {
"organization_slug": react_project.organization.slug,
"MAX_DAYS": MAX_DAYS,
"SCALE_FACTOR": SCALE_FACTOR,
}
logger.info("populate_connected_event_scenario_1.start", extra=log_extra)
for day in range(MAX_DAYS):
for hour in range(24):
base = distribution_v1(hour)
# determine the number of events we want in this hour
num_events = int(
(BASE_OFFSET + SCALE_FACTOR * base) * random.uniform(0.6, 1.0))
timestamps = []
for i in range(num_events):
logger.info(
"populate_connected_event_scenario_1.send_event_series",
extra=log_extra)
# pick the minutes randomly (which means events will sent be out of order)
minute = random.randint(0, 60)
timestamp = start_time + timedelta(
days=day, hours=hour, minutes=minute)
timestamp = timestamp.replace(tzinfo=pytz.utc)
timestamps.append(timestamp)
# sort the timestamps
timestamps.sort()
for timestamp in timestamps:
transaction_user = generate_user(quick)
trace_id = uuid4().hex
release = get_release_from_time(react_project.organization_id,
timestamp)
release_sha = release.version
old_span_id = react_transaction["contexts"]["trace"]["span_id"]
frontend_root_span_id = uuid4().hex[:16]
frontend_duration = random_normal(2000 - 50 * day, 250,
1000) / 1000.0
frontend_context = {
"trace": {
"type": "trace",
"trace_id": trace_id,
"span_id": frontend_root_span_id,
}
}
# React transaction
local_event = copy.deepcopy(react_transaction)
local_event.update(
project=react_project,
platform=react_project.platform,
event_id=uuid4().hex,
user=transaction_user,
release=release_sha,
timestamp=timestamp,
# start_timestamp decreases based on day so that there's a trend
start_timestamp=timestamp -
timedelta(seconds=frontend_duration),
measurements={
"fp": {
"value": random_normal(1250 - 50 * day, 200, 500)
},
"fcp": {
"value": random_normal(1250 - 50 * day, 200, 500)
},
"lcp": {
"value": random_normal(2800 - 50 * day, 400, 2000)
},
"fid": {
"value": random_normal(5 - 0.125 * day, 2, 1)
},
},
contexts=frontend_context,
)
fix_transaction_event(local_event, old_span_id)
safe_send_event(local_event, quick)
# note picking the 0th span is arbitrary
backend_parent_id = local_event["spans"][0]["span_id"]
# React error
local_event = copy.deepcopy(react_error)
local_event.update(
project=react_project,
platform=react_project.platform,
timestamp=timestamp,
user=transaction_user,
release=release_sha,
contexts=frontend_context,
)
fix_error_event(local_event, quick)
safe_send_event(local_event, quick)
# python transaction
old_span_id = python_transaction["contexts"]["trace"][
"span_id"]
backend_duration = random_normal(1500 + 50 * day, 250, 500)
backend_context = {
"trace": {
"type": "trace",
"trace_id": trace_id,
"span_id": uuid4().hex[:16],
"parent_span_id": backend_parent_id,
}
}
local_event = copy.deepcopy(python_transaction)
local_event.update(
project=python_project,
platform=python_project.platform,
timestamp=timestamp,
start_timestamp=timestamp -
timedelta(milliseconds=backend_duration),
user=transaction_user,
release=release_sha,
contexts=backend_context,
)
fix_transaction_event(local_event, old_span_id)
safe_send_event(local_event, quick)
# python error
local_event = copy.deepcopy(python_error)
local_event.update(
project=python_project,
platform=python_project.platform,
timestamp=timestamp,
user=transaction_user,
release=release_sha,
contexts=backend_context,
)
fix_error_event(local_event, quick)
safe_send_event(local_event, quick)
logger.info("populate_connected_event_scenario_1.finished",
extra=log_extra)
