def pod_oom_killer_enricher(event: PodEvent, params: OomKillParams):
    """
    Retrieves pod and node information for an OOMKilled pod
    """
    pod = event.get_pod()
    if not pod:
        logging.error(f"cannot run pod_oom_killer_enricher on event with no pod: {event}")
        return

    finding = Finding(
        title=f"Pod {pod.metadata.name} in namespace {pod.metadata.namespace} OOMKilled results",
        aggregation_key="PodOOMKilled",
        source=FindingSource.KUBERNETES_API_SERVER,
        severity=FindingSeverity.HIGH,
        subject=PodFindingSubject(pod),
    )

    node = pod.get_node()
    labels = [
        ("Pod", pod.metadata.name),
        ("Namespace", pod.metadata.namespace),
    ]

    if node:
        allocatable_memory = PodResources.parse_mem(node.status.allocatable.get("memory", "0Mi"))
        capacity_memory = PodResources.parse_mem(node.status.capacity.get("memory", "0Mi"))
        allocated_precent = (capacity_memory - allocatable_memory) * 100 / capacity_memory

        node_labels = [
            ("Node Name", pod.spec.nodeName),
            (
                "Node allocated memory",
                f"{allocated_precent:.2f}% out of {allocatable_memory}MB allocatable",
            ),
        ]

        blocks = [
            TableBlock(
                [[k, v] for (k, v) in node_labels],
                ["field", "value"],
                table_name="*Node Info*",
            )
        ]
        if params.node_memory_graph:
            node_graph = create_node_graph_enrichment(params, node, metrics_legends_labels=["pod"])
            blocks.append(node_graph)

        finding.add_enrichment(blocks, enrichment_type=EnrichmentType.node_info, title="Node Info")

    else:
        logging.warning(f"Node {pod.spec.nodeName} not found for OOMKilled pod {pod.metadata.name}")

    oomkilled_container = pod_most_recent_oom_killed_container(pod)
    if not oomkilled_container or not oomkilled_container.state:
        logging.error(f"could not find OOMKilled status in pod {pod.metadata.name}")
        container_name = None
    else:
        container_labels: List[Tuple[str, str]] = []
        container_labels.extend(labels)
        if oomkilled_container.container is not None:
            container_name = oomkilled_container.container.name
            requests, limits = PodContainer.get_memory_resources(oomkilled_container.container)
            memory_limit = "No limit" if not limits else f"{limits}MB limit"
            memory_requests = "No request" if not requests else f"{requests}MB request"
            container_labels.append(("Container memory", f"{memory_requests}, {memory_limit}"))
            container_labels.append(("Container name", container_name))
        else:
            container_name = None

        oom_killed_status = oomkilled_container.state
        if oom_killed_status.terminated.startedAt:
            container_labels.append(("Container started at", oom_killed_status.terminated.startedAt))
        if oom_killed_status.terminated.finishedAt:
            container_labels.append(("Container finished at", oom_killed_status.terminated.finishedAt))

        blocks = [
            TableBlock(
                [[k, v] for (k, v) in container_labels],
                ["field", "value"],
                table_name="*Container Info*",
            )
        ]
        if params.container_memory_graph and oomkilled_container.container:
            container_graph = get_oomkilled_graph(oomkilled_container, pod, params, metrics_legends_labels=["pod"])
            blocks.append(container_graph)

        finding.add_enrichment(blocks, enrichment_type=EnrichmentType.container_info, title="Container Info")

    event.add_finding(finding)
    if params.attach_logs and container_name is not None:
        logs_enricher(event, LogEnricherParams(container_name=container_name))

    if params.dmesg_log and node:
        dmesg_enricher(event, node, params.custom_annotations)

    Retrieves pod and node information for an OOMKilled pod
    
playbooks/robusta_playbooks/oom_killer.py