clue-python-sdk-core 0.0.1__py3-none-any.whl

clue_python_sdk_core/celery.py

@@ -0,0 +1,734 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Mapping, Sequence
+
+from .adapters import (
+	JsonValue,
+	_build_schema_evidence,
+	build_celery_job_event,
+	build_summary_event,
+)
+from .contracts import QUEUE_LIFECYCLE_SUMMARY_EVENT, SDK_COLLECTION_MODE_STANDARD
+from .otel_bridge import annotate_current_otel_span, merge_current_otel_span_context
+from .privacy import fingerprint_value
+from .runtime import (
+	CluePythonSettings,
+	create_client,
+	create_request_context,
+	flush_client,
+	get_current_client,
+	get_current_context,
+	load_settings,
+	reset_current_state,
+	set_current_state,
+)
+
+_task_state: dict[str, tuple[object, object, float, object, object]] = {}
+_publish_state: dict[str, dict[str, JsonValue]] = {}
+_CELERY_MESSAGE_FINGERPRINT_SECRET = "clue-backend-sdk-celery-message"
+_MAX_PUBLISH_STATE_ENTRIES = 1024
+_MAX_PAYLOAD_SCHEMA_WIDTH = 50
+_MAX_PAYLOAD_SCHEMA_DEPTH = 6
+
+
+def _duration_bucket(duration_ms: int) -> str:
+	if duration_ms < 100:
+		return "lt_100ms"
+	if duration_ms < 1_000:
+		return "100_999ms"
+	if duration_ms < 10_000:
+		return "1000_9999ms"
+	return "gte_10000ms"
+
+
+def _record_summary_metric(client: object, count: int = 1) -> None:
+	record = getattr(client, "record_events_summarized", None)
+	if callable(record):
+		record(count)
+
+
+def _add_summary_event(client: object, event: Mapping[str, JsonValue]) -> bool:
+	added = getattr(client, "add_event")(event)
+	if added:
+		_record_summary_metric(client)
+	return bool(added)
+
+
+def instrument_celery_signals(
+	*,
+	task_prerun: object,
+	task_postrun: object,
+	task_failure: object,
+	before_task_publish: object | None = None,
+	after_task_publish: object | None = None,
+	task_retry: object | None = None,
+	task_revoked: object | None = None,
+	settings_loader=load_settings,
+) -> bool:
+	settings: CluePythonSettings = settings_loader()
+	if not settings.enabled or not settings.capture_celery:
+		return False
+
+	def on_before_task_publish(
+		sender=None,
+		body=None,
+		headers=None,
+		properties=None,
+		exchange=None,
+		routing_key=None,
+		**kwargs,
+	):
+		current_context = get_current_context()
+		message_id_raw = _message_id(headers, properties)
+		correlation_id = _masked_message_id(message_id_raw)
+		published_at_ms = int(time.time() * 1000)
+		parent_request_span_id = (
+			_string_or_none(current_context.get("request_span_id"))
+			if current_context is not None
+			else None
+		)
+		_inject_publish_headers(
+			headers=headers,
+			correlation_id=correlation_id,
+			parent_request_span_id=parent_request_span_id,
+			published_at_ms=published_at_ms,
+		)
+		state_key = _publish_state_key(headers, properties, sender)
+		payload_evidence = _payload_schema_evidence(body, settings=settings)
+		_remember_publish_state(
+			state_key,
+			{
+				"message_type": _message_type(sender, headers),
+				"destination_name": _destination_name(routing_key, exchange),
+				"queue_name": _destination_name(routing_key, exchange),
+				"message_id_masked": correlation_id,
+				"correlation_id": correlation_id,
+				"parent_request_span_id": parent_request_span_id,
+				"published_at_ms": published_at_ms,
+				"payload_schema_hash": payload_evidence["schema_hash"],
+				"payload_shape_size": payload_evidence["shape_size"],
+				"payload_field_paths": payload_evidence["field_paths"],
+			},
+		)
+
+	def on_after_task_publish(
+		sender=None,
+		body=None,
+		headers=None,
+		properties=None,
+		exchange=None,
+		routing_key=None,
+		**kwargs,
+	):
+		state_key = _publish_state_key(headers, properties, sender)
+		publish_state = _publish_state.pop(state_key, None) or {}
+		current_client = get_current_client()
+		current_context = get_current_context()
+		created_client = None
+		client = current_client
+		context = current_context
+		if client is None or context is None:
+			created_client = create_client(settings)
+			if created_client is None:
+				return
+			client = created_client
+			context = create_request_context(
+				settings=settings,
+				service_name=settings.service_name,
+				request_id=_string_or_none(_message_id(headers, properties)),
+			)
+		payload_evidence = (
+			{
+				"schema_hash": publish_state.get("payload_schema_hash"),
+				"shape_size": publish_state.get("payload_shape_size") or 0,
+				"field_paths": publish_state.get("payload_field_paths") or [],
+			}
+			if publish_state
+			else _payload_schema_evidence(body, settings=settings)
+		)
+		message_id_masked = (
+			_string_or_none(publish_state.get("message_id_masked"))
+			or _masked_message_id(_message_id(headers, properties))
+		)
+		parent_request_span_id = (
+			_string_or_none(publish_state.get("parent_request_span_id"))
+			or (
+				_string_or_none(current_context.get("request_span_id"))
+				if current_context is not None
+				else None
+			)
+		)
+		_add_summary_event(
+			client,
+			_queue_summary_event(
+				context=context,
+				settings=settings,
+				message_operation="publish",
+				detail_reason=(
+					"request_linked_publish"
+					if parent_request_span_id is not None
+					else "diagnostic_sample"
+				),
+				message_type=(
+					_string_or_none(publish_state.get("message_type"))
+					or _message_type(sender, headers)
+				),
+				destination_name=(
+					_string_or_none(publish_state.get("destination_name"))
+					or _destination_name(routing_key, exchange)
+				),
+				queue_name=(
+					_string_or_none(publish_state.get("queue_name"))
+					or _destination_name(routing_key, exchange)
+				),
+				message_id_masked=message_id_masked,
+				correlation_id=message_id_masked,
+				parent_request_span_id=parent_request_span_id,
+				payload_schema_hash=_string_or_none(payload_evidence["schema_hash"]),
+				payload_shape_size=_int_or_none(payload_evidence["shape_size"]),
+				payload_field_paths=_string_list(payload_evidence["field_paths"]),
+				metrics={"publish_count": 1},
+			),
+		)
+		if created_client is not None:
+			flush_client(created_client)
+
+	def on_task_prerun(task_id=None, task=None, **kwargs):
+		client = create_client(settings)
+		if client is None:
+			return
+		context = merge_current_otel_span_context(
+			create_request_context(
+				settings=settings,
+				service_name=settings.service_name,
+				request_id=str(task_id) if task_id is not None else None,
+			),
+			expected_kind="CONSUMER",
+		)
+		annotate_current_otel_span(
+			{
+				"clue.job.type": _task_name(task),
+				"clue.job.id": str(task_id) if task_id is not None else None,
+				"clue.job.queue_name": _queue_name(task),
+			},
+			expected_kind="CONSUMER",
+		)
+		if settings.sdk_collection_mode != SDK_COLLECTION_MODE_STANDARD:
+			client.add_event(
+				build_celery_job_event(
+					context=context,
+					status="started",
+					task_name=_task_name(task),
+					task_id=str(task_id) if task_id is not None else None,
+					queue_name=_queue_name(task),
+					correlation_id=_task_correlation_id(task, task_id),
+					message_id_masked=_task_correlation_id(task, task_id),
+					parent_request_span_id=_task_parent_request_span_id(task),
+					delay_ms=_task_delay_ms(task),
+					attempt_count=_task_attempt_count(task),
+					max_attempts=_task_max_attempts(task),
+				)
+			)
+		client_token, context_token = set_current_state(client=client, context=context)
+		_task_state[str(task_id)] = (
+			client,
+			context,
+			time.perf_counter(),
+			client_token,
+			context_token,
+		)
+
+	def on_task_postrun(task_id=None, task=None, **kwargs):
+		state = _task_state.pop(str(task_id), None)
+		if state is None:
+			return
+		client, context, started_at, client_token, context_token = state
+		duration_ms = int((time.perf_counter() - started_at) * 1000)
+		if settings.sdk_collection_mode == SDK_COLLECTION_MODE_STANDARD:
+			event = _queue_summary_event(
+				context=context,
+				settings=settings,
+				message_operation="consume",
+				detail_reason="success",
+				message_type=_task_name(task),
+				destination_name=_queue_name(task),
+				queue_name=_queue_name(task),
+				message_id_masked=_task_correlation_id(task, task_id),
+				correlation_id=_task_correlation_id(task, task_id),
+				parent_request_span_id=_task_parent_request_span_id(task),
+				attempt_count=_task_attempt_count(task),
+				max_attempts=_task_max_attempts(task),
+				delay_ms=_task_delay_ms(task),
+				metrics={
+					"duration_ms": duration_ms,
+					"normal_success_count": 1,
+					"job_type_present": 1 if _task_name(task) != "unknown" else 0,
+				},
+			)
+			event["properties"]["job_type"] = _task_name(task)
+			event["properties"]["result_kind"] = "success"
+			event["properties"]["duration_bucket"] = _duration_bucket(duration_ms)
+			_add_summary_event(client, event)
+		else:
+			client.add_event(
+				build_celery_job_event(
+					context=context,
+					status="finished",
+					task_name=_task_name(task),
+					task_id=str(task_id) if task_id is not None else None,
+					queue_name=_queue_name(task),
+					duration_ms=duration_ms,
+					correlation_id=_task_correlation_id(task, task_id),
+					message_id_masked=_task_correlation_id(task, task_id),
+					parent_request_span_id=_task_parent_request_span_id(task),
+					delay_ms=_task_delay_ms(task),
+					attempt_count=_task_attempt_count(task),
+					max_attempts=_task_max_attempts(task),
+				)
+			)
+		reset_current_state(client_token, context_token)
+		flush_client(client)
+
+	def on_task_failure(task_id=None, task=None, exception=None, **kwargs):
+		state = _task_state.pop(str(task_id), None)
+		if state is None:
+			return
+		client, context, started_at, client_token, context_token = state
+		client.add_event(
+			build_celery_job_event(
+				context=context,
+				status="failed",
+				task_name=_task_name(task),
+				task_id=str(task_id) if task_id is not None else None,
+				queue_name=_queue_name(task),
+				duration_ms=int((time.perf_counter() - started_at) * 1000),
+				failure_reason=exception.__class__.__name__ if exception is not None else None,
+				correlation_id=_task_correlation_id(task, task_id),
+				message_id_masked=_task_correlation_id(task, task_id),
+				parent_request_span_id=_task_parent_request_span_id(task),
+				delay_ms=_task_delay_ms(task),
+				attempt_count=_task_attempt_count(task),
+				max_attempts=_task_max_attempts(task),
+				failure_type=exception.__class__.__name__ if exception is not None else "failed",
+				detail_reason="failed",
+			)
+		)
+		reset_current_state(client_token, context_token)
+		flush_client(client)
+
+	def on_task_retry(request=None, reason=None, **kwargs):
+		emit_context = get_current_context()
+		emit_client = get_current_client()
+		created_client = None
+		if emit_client is None or emit_context is None:
+			created_client = create_client(settings)
+			if created_client is None:
+				return
+			emit_client = created_client
+			emit_context = create_request_context(
+				settings=settings,
+				service_name=settings.service_name,
+				request_id=_string_or_none(_request_attr(request, "id")),
+			)
+		_add_summary_event(
+			emit_client,
+			_queue_summary_event(
+				context=emit_context,
+				settings=settings,
+				message_operation="retry",
+				detail_reason="retry",
+				message_type=_string_or_none(_request_attr(request, "task")),
+				destination_name=_request_queue_name(request),
+				queue_name=_request_queue_name(request),
+				message_id_masked=_masked_message_id(_request_attr(request, "id")),
+				correlation_id=_request_correlation_id(request),
+				parent_request_span_id=_request_parent_request_span_id(request),
+				attempt_count=_request_attempt_count(request),
+				failure_type=reason.__class__.__name__ if reason is not None else "retry",
+				metrics={"retry_count": 1},
+			),
+		)
+		if created_client is not None:
+			flush_client(created_client)
+
+	def on_task_revoked(request=None, terminated=None, expired=None, **kwargs):
+		emit_client = create_client(settings)
+		if emit_client is None:
+			return
+		emit_context = create_request_context(
+			settings=settings,
+			service_name=settings.service_name,
+			request_id=_string_or_none(_request_attr(request, "id")),
+		)
+		_add_summary_event(
+			emit_client,
+			_queue_summary_event(
+				context=emit_context,
+				settings=settings,
+				message_operation="revoke",
+				detail_reason="failed",
+				message_type=_string_or_none(_request_attr(request, "task")),
+				destination_name=_request_queue_name(request),
+				queue_name=_request_queue_name(request),
+				message_id_masked=_masked_message_id(_request_attr(request, "id")),
+				correlation_id=_request_correlation_id(request),
+				parent_request_span_id=_request_parent_request_span_id(request),
+				attempt_count=_request_attempt_count(request),
+				failure_type="revoked",
+				dlq_reason="unavailable",
+				metrics={
+					"revoked_count": 1,
+					"terminated_count": 1 if terminated else 0,
+					"expired_count": 1 if expired else 0,
+				},
+			),
+		)
+		flush_client(emit_client)
+
+	task_prerun.connect(on_task_prerun, weak=False)
+	task_postrun.connect(on_task_postrun, weak=False)
+	task_failure.connect(on_task_failure, weak=False)
+	_connect_optional_signal(before_task_publish, on_before_task_publish)
+	_connect_optional_signal(after_task_publish, on_after_task_publish)
+	_connect_optional_signal(task_retry, on_task_retry)
+	_connect_optional_signal(task_revoked, on_task_revoked)
+	return True
+
+
+def _connect_optional_signal(signal: object | None, receiver: object) -> None:
+	if signal is None:
+		return
+	connect = getattr(signal, "connect", None)
+	if callable(connect):
+		connect(receiver, weak=False)
+
+
+def _task_name(task: object) -> str:
+	name = getattr(task, "name", None)
+	if isinstance(name, str) and name.strip():
+		return name
+	return "unknown"
+
+
+def _queue_name(task: object) -> str | None:
+	request = getattr(task, "request", None)
+	delivery_info = getattr(request, "delivery_info", None)
+	if isinstance(delivery_info, dict):
+		routing_key = delivery_info.get("routing_key")
+		if isinstance(routing_key, str) and routing_key.strip():
+			return routing_key
+	return None
+
+
+def _string_or_none(value: object) -> str | None:
+	return value.strip() if isinstance(value, str) and value.strip() else None
+
+
+def _int_or_none(value: object) -> int | None:
+	if isinstance(value, bool):
+		return None
+	try:
+		parsed = int(str(value))
+	except (TypeError, ValueError):
+		return None
+	return parsed if parsed >= 0 else None
+
+
+def _string_list(value: object) -> list[str]:
+	if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)):
+		return []
+	result: list[str] = []
+	for entry in value:
+		text = _string_or_none(entry)
+		if text is not None:
+			result.append(text)
+	return result
+
+
+def _message_id(headers: object, properties: object) -> str | None:
+	for source in (headers, properties):
+		if isinstance(source, Mapping):
+			for key in ("correlation_id", "correlation-id", "id", "task_id"):
+				text = _string_or_none(source.get(key))
+				if text is not None:
+					return text
+	return None
+
+
+def _masked_message_id(value: object) -> str | None:
+	text = _string_or_none(value)
+	if text is None:
+		return None
+	return fingerprint_value(text, _CELERY_MESSAGE_FINGERPRINT_SECRET)
+
+
+def _message_type(sender: object, headers: object) -> str:
+	if isinstance(headers, Mapping):
+		for key in ("task", "type", "message_type"):
+			text = _string_or_none(headers.get(key))
+			if text is not None:
+				return text
+	text = _string_or_none(sender)
+	return text or "unknown"
+
+
+def _destination_name(routing_key: object, exchange: object) -> str | None:
+	return _string_or_none(routing_key) or _string_or_none(exchange)
+
+
+def _publish_state_key(headers: object, properties: object, sender: object) -> str:
+	message_id = _message_id(headers, properties)
+	if message_id is not None:
+		return f"id:{message_id}"
+	return f"sender:{_message_type(sender, headers)}:{id(headers)}:{id(properties)}"
+
+
+def _remember_publish_state(key: str, value: Mapping[str, JsonValue]) -> None:
+	if len(_publish_state) >= _MAX_PUBLISH_STATE_ENTRIES:
+		_publish_state.pop(next(iter(_publish_state)), None)
+	_publish_state[key] = dict(value)
+
+
+def _bounded_schema_input(value: object, *, depth: int = 0) -> object:
+	if depth >= _MAX_PAYLOAD_SCHEMA_DEPTH:
+		return None
+	if isinstance(value, Mapping):
+		result: dict[str, object] = {}
+		for index, key in enumerate(sorted(value.keys(), key=str)):
+			if index >= _MAX_PAYLOAD_SCHEMA_WIDTH:
+				result["_clue_truncated_keys"] = True
+				break
+			result[str(key)] = _bounded_schema_input(value[key], depth=depth + 1)
+		return result
+	if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+		items = list(value)
+		if not items:
+			return []
+		return [_bounded_schema_input(items[0], depth=depth + 1)]
+	return value
+
+
+def _payload_schema_evidence(
+	body: object,
+	*,
+	settings: CluePythonSettings,
+) -> dict[str, JsonValue]:
+	return _build_schema_evidence(
+		_bounded_schema_input(_celery_payload_schema_input(body)),
+		denied_keys=settings.denied_keys,
+	)
+
+
+def _celery_payload_schema_input(body: object) -> object:
+	if isinstance(body, Sequence) and not isinstance(body, (str, bytes, bytearray)):
+		items = list(body)
+		if len(items) >= 2:
+			return {
+				"args": items[0],
+				"kwargs": items[1],
+			}
+	return body
+
+
+def _inject_publish_headers(
+	*,
+	headers: object,
+	correlation_id: str | None,
+	parent_request_span_id: str | None,
+	published_at_ms: int,
+) -> None:
+	if not isinstance(headers, dict):
+		return
+	if correlation_id is not None:
+		headers.setdefault("x-clue-correlation-id", correlation_id)
+	if parent_request_span_id is not None:
+		headers.setdefault("x-clue-parent-request-span-id", parent_request_span_id)
+	headers.setdefault("x-clue-published-at-ms", str(published_at_ms))
+
+
+def _task_headers(task: object) -> Mapping[str, object]:
+	request = getattr(task, "request", None)
+	headers = getattr(request, "headers", None)
+	return headers if isinstance(headers, Mapping) else {}
+
+
+def _task_correlation_id(task: object, task_id: object) -> str | None:
+	headers = _task_headers(task)
+	return (
+		_string_or_none(headers.get("x-clue-correlation-id"))
+		or _masked_message_id(_request_attr(getattr(task, "request", None), "correlation_id"))
+		or _masked_message_id(task_id)
+	)
+
+
+def _task_parent_request_span_id(task: object) -> str | None:
+	return _string_or_none(_task_headers(task).get("x-clue-parent-request-span-id"))
+
+
+def _task_delay_ms(task: object) -> int | None:
+	published_at_ms = _int_or_none(_task_headers(task).get("x-clue-published-at-ms"))
+	if published_at_ms is None:
+		return None
+	return max(0, int(time.time() * 1000) - published_at_ms)
+
+
+def _task_attempt_count(task: object) -> int | None:
+	return _int_or_none(_request_attr(getattr(task, "request", None), "retries"))
+
+
+def _task_max_attempts(task: object) -> int | None:
+	return _int_or_none(getattr(task, "max_retries", None))
+
+
+def _request_attr(request: object, name: str) -> object:
+	return getattr(request, name, None) if request is not None else None
+
+
+def _request_headers(request: object) -> Mapping[str, object]:
+	headers = _request_attr(request, "headers")
+	return headers if isinstance(headers, Mapping) else {}
+
+
+def _request_correlation_id(request: object) -> str | None:
+	headers = _request_headers(request)
+	return (
+		_string_or_none(headers.get("x-clue-correlation-id"))
+		or _masked_message_id(_request_attr(request, "correlation_id"))
+		or _masked_message_id(_request_attr(request, "id"))
+	)
+
+
+def _request_parent_request_span_id(request: object) -> str | None:
+	return _string_or_none(_request_headers(request).get("x-clue-parent-request-span-id"))
+
+
+def _request_queue_name(request: object) -> str | None:
+	delivery_info = _request_attr(request, "delivery_info")
+	if isinstance(delivery_info, Mapping):
+		return _string_or_none(delivery_info.get("routing_key"))
+	return None
+
+
+def _request_attempt_count(request: object) -> int | None:
+	return _int_or_none(_request_attr(request, "retries"))
+
+
+def _queue_summary_event(
+	*,
+	context: Mapping[str, JsonValue],
+	settings: CluePythonSettings,
+	message_operation: str,
+	detail_reason: str,
+	message_type: str | None = None,
+	destination_name: str | None = None,
+	queue_name: str | None = None,
+	message_id_masked: str | None = None,
+	correlation_id: str | None = None,
+	parent_request_span_id: str | None = None,
+	payload_schema_hash: str | None = None,
+	payload_shape_size: int | None = None,
+	payload_field_paths: Sequence[str] = (),
+	attempt_count: int | None = None,
+	max_attempts: int | None = None,
+	delay_ms: int | None = None,
+	failure_type: str | None = None,
+	dlq_reason: str | None = None,
+	metrics: Mapping[str, int | float] | None = None,
+) -> dict[str, JsonValue]:
+	properties: dict[str, JsonValue] = {
+		"message_operation": message_operation,
+		"messaging_system": "celery",
+		"detail_reason": detail_reason,
+		"message_type": message_type,
+		"destination_name": destination_name,
+		"queue_name": queue_name,
+		"message_id_masked": message_id_masked,
+		"correlation_id": correlation_id,
+		"parent_request_span_id": parent_request_span_id,
+		"payload_schema_hash": payload_schema_hash,
+		"payload_shape_size": payload_shape_size,
+		"payload_field_paths": list(payload_field_paths),
+		"attempt_count": attempt_count,
+		"max_attempts": max_attempts,
+		"delay_ms": delay_ms,
+		"failure_type": failure_type,
+		"dlq_reason": dlq_reason,
+		"dlq_capture": "unavailable",
+	}
+	summary_metrics = dict(metrics or {})
+	if delay_ms is not None:
+		summary_metrics["delay_ms"] = delay_ms
+	if attempt_count is not None:
+		summary_metrics["attempt_count"] = attempt_count
+	event = build_summary_event(
+		context=context,
+		event_name=QUEUE_LIFECYCLE_SUMMARY_EVENT,
+		collector_name="celery",
+		aggregation_kind=message_operation,
+		summary_window_ms=0,
+		summary_count=1,
+		budget_window_ms=60_000,
+		rate_limit_key=f"queue:{queue_name or destination_name or 'unknown'}:{message_operation}",
+		properties=properties,
+		metrics=summary_metrics,
+		denied_keys=settings.denied_keys,
+	)
+	_enrich_queue_event(
+		event,
+		correlation_id=correlation_id,
+		message_id_masked=message_id_masked,
+		parent_request_span_id=parent_request_span_id,
+		message_operation=message_operation,
+		messaging_system="celery",
+		detail_reason=detail_reason,
+		destination_name=destination_name,
+		message_type=message_type,
+		attempt_count=attempt_count,
+		max_attempts=max_attempts,
+		delay_ms=delay_ms,
+		failure_type=failure_type,
+		dlq_reason=dlq_reason,
+		payload_schema_hash=payload_schema_hash,
+	)
+	return event
+
+
+def _enrich_queue_event(
+	event: object,
+	*,
+	correlation_id: str | None = None,
+	message_id_masked: str | None = None,
+	parent_request_span_id: str | None = None,
+	message_operation: str | None = None,
+	messaging_system: str | None = None,
+	detail_reason: str | None = None,
+	destination_name: str | None = None,
+	message_type: str | None = None,
+	attempt_count: int | None = None,
+	max_attempts: int | None = None,
+	delay_ms: int | None = None,
+	failure_type: str | None = None,
+	dlq_reason: str | None = None,
+	payload_schema_hash: str | None = None,
+) -> None:
+	if not isinstance(event, dict):
+		return
+	event.update(
+		{
+			"correlation_id": correlation_id,
+			"message_id_masked": message_id_masked,
+			"parent_request_span_id": parent_request_span_id,
+			"message_operation": message_operation,
+			"messaging_system": messaging_system,
+			"detail_reason": detail_reason,
+			"destination_name": destination_name,
+			"message_type": message_type,
+			"attempt_count": attempt_count,
+			"max_attempts": max_attempts,
+			"delay_ms": delay_ms,
+			"failure_type": failure_type,
+			"dlq_reason": dlq_reason,
+			"payload_schema_hash": payload_schema_hash,
+		}
+	)