def test_run_migration_in_full(self):
self.migration.sec.reset_count()
migration_successful = start_async_migration("test")
sm = AsyncMigration.objects.get(name="test")
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM test_async_migration")
res = cursor.fetchone()
self.assertEqual(res, ("a", "c"))
self.assertTrue(migration_successful)
self.assertEqual(sm.name, "test")
self.assertEqual(sm.description, self.TEST_MIGRATION_DESCRIPTION)
self.assertEqual(sm.status, MigrationStatus.CompletedSuccessfully)
self.assertEqual(sm.progress, 100)
errors = AsyncMigrationError.objects.filter(async_migration=sm)
self.assertEqual(errors.count(), 0)
self.assertTrue(UUIDT.is_valid_uuid(sm.current_query_id))
self.assertEqual(sm.current_operation_index, 7)
self.assertEqual(sm.posthog_min_version, "1.0.0")
self.assertEqual(sm.posthog_max_version, "100000.0.0")
self.assertEqual(sm.finished_at.day, datetime.today().day)
self.assertEqual(self.migration.sec.side_effect_count, 3)
self.assertEqual(self.migration.sec.side_effect_rollback_count, 0)
def retrieve(self, request: Request, pk: Optional[Union[int, str]] = None, *args: Any, **kwargs: Any) -> Response:
if not isinstance(pk, str) or not UUIDT.is_valid_uuid(pk):
return Response({"detail": "Invalid UUID", "code": "invalid", "type": "validation_error",}, status=400)
query_result = sync_execute(SELECT_ONE_EVENT_SQL, {"team_id": self.team.pk, "event_id": pk.replace("-", "")})
if len(query_result) == 0:
raise NotFound(detail=f"No events exist for event UUID {pk}")
res = ClickhouseEventSerializer(query_result[0], many=False).data
return Response(res)
def get_event(request):
timer = statsd.timer("posthog_cloud_event_endpoint").start()
now = timezone.now()
data, error_response = get_data(request)
if error_response:
return error_response
sent_at = _get_sent_at(data, request)
token = get_token(data, request)
if not token:
return cors_response(
request,
generate_exception_response(
"capture",
"API key not provided. You can find your project API key in PostHog project settings.",
type="authentication_error",
code="missing_api_key",
status_code=status.HTTP_401_UNAUTHORIZED,
),
)
ingestion_context, db_error, error_response = get_event_ingestion_context(request, data, token)
if error_response:
return error_response
send_events_to_dead_letter_queue = False
if db_error:
send_events_to_dead_letter_queue = True
if isinstance(data, dict):
if data.get("batch"): # posthog-python and posthog-ruby
data = data["batch"]
assert data is not None
elif "engage" in request.path_info: # JS identify call
data["event"] = "$identify" # make sure it has an event name
if isinstance(data, list):
events = data
else:
events = [data]
try:
events = preprocess_session_recording_events(events)
except ValueError as e:
return cors_response(
request, generate_exception_response("capture", f"Invalid payload: {e}", code="invalid_payload")
)
site_url = request.build_absolute_uri("/")[:-1]
ip = None if not ingestion_context or ingestion_context.anonymize_ips else get_ip_address(request)
for event in events:
event_uuid = UUIDT()
distinct_id = get_distinct_id(event)
if not distinct_id:
continue
payload_uuid = event.get("uuid", None)
if payload_uuid:
if UUIDT.is_valid_uuid(payload_uuid):
event_uuid = UUIDT(uuid_str=payload_uuid)
else:
statsd.incr("invalid_event_uuid")
event = parse_event(event, distinct_id, ingestion_context)
if not event:
continue
if send_events_to_dead_letter_queue:
kafka_event = parse_kafka_event_data(
distinct_id=distinct_id,
ip=None,
site_url=site_url,
team_id=None,
now=now,
event_uuid=event_uuid,
data=event,
sent_at=sent_at,
)
log_event_to_dead_letter_queue(
data,
event["event"],
kafka_event,
f"Unable to fetch team from Postgres. Error: {db_error}",
"django_server_capture_endpoint",
)
continue
try:
capture_internal(event, distinct_id, ip, site_url, now, sent_at, ingestion_context.team_id, event_uuid) # type: ignore
except Exception as e:
timer.stop()
capture_exception(e, {"data": data})
statsd.incr(
"posthog_cloud_raw_endpoint_failure", tags={"endpoint": "capture",},
)
return cors_response(
request,
generate_exception_response(
"capture",
"Unable to store event. Please try again. If you are the owner of this app you can check the logs for further details.",
code="server_error",
type="server_error",
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
),
)
timer.stop()
statsd.incr(
"posthog_cloud_raw_endpoint_success", tags={"endpoint": "capture",},
)
return cors_response(request, JsonResponse({"status": 1}))