[BUG] HostInterface is not resolved properly

[Mees-Molenaar]

Hi,

The HostInterface TracingLoggin correctly binds to the components importing wasi:logging. However, since the http-server component does not import wasi:logging but calls a component that does import wasi:logging it does find the plugin in the context.

Additionally, the same kind of flow, but then to a component does work fine (see schema below).

The logs indicate that the betty-blocks/action and betty-blocks/logging both bind to the plugin. However, since the betty-blocks/action is dynamic, the http-server component cannot know that it needs to import wasi:logging. Therefore, that component does not get bound to the plugin. I believe that wasmCloud's core-functionality is this kind of dynamic linking and this works for component-component, so therefore this seems a bug to me.

Logs of components binding to the TracingPlugin:

hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:26:06.191228Z  WARN TracingLogging binding component
hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:26:06.191256Z  WARN TracingLogging binding component DONE. ID dde082a5-3f3c-4d9f-b8c6-03e9184f589c WORKLOAD ID: bb747046-e578-422c-9f66-3b3aba6c1e86
hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:26:06.191269Z DEBUG binding plugin to workload component plugin_id="wasi-logging" component_id="bf78200b-9022-4d24-bf1a-b07bd25b9d69" interfaces={WitInterface { namespace: "wasi", package: "logging", interfaces: {"logging"}, version: None, config: {} }}
hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:26:06.191275Z  WARN TracingLogging binding component
hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:26:06.191283Z  WARN TracingLogging binding component DONE. ID bf78200b-9022-4d24-bf1a-b07bd25b9d69 WORKLOAD ID: bb747046-e578-422c-9f66-3b3aba6c1e86

Logs of the call to the http-server:

 DEBUG HTTP request received method=POST uri=/ host=bb747046-e578-422c-9f66-3b3aba6c1e86
hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:27:24.725872Z DEBUG looking up workload handle for host header host=bb747046-e578-422c-9f66-3b3aba6c1e86
hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:27:24.734571Z  WARN TracingLogging plugin not found in context component id: f03c4f1f-7a1f-436e-9ebc-0f272a058635
hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:27:24.734873Z ERROR error receiving http response err=RecvError(())
hostgroup-default-787f4885c5-5q7w9 host 2025-12-15T16:27:24.734888Z ERROR failed to invoke component err=oneshot channel closed but no response was sent host=bb747046-e578-422c-9f66-3b3aba6c1e86

Do you have any thoughts on this? If you need more information, please let me know.

Mees

[if0ne]

Hi,

Could you provide the entire TracingLogging implementation code? I am interested in HostPlugin trait and wasi::logging Host implementation

[Mees-Molenaar]

It is the provided loggin implementation in crates/wash-runtime/src/washlet/plugin/wasi_logging.rs, I only added some extra logs to get to know which components are binding to the Plugin.

//! # WASI Logging Plugin
//!
//! This module routes logging calls from WASI components to the host's tracing
//! system. It implements the `wasi:logging/logging` interface, allowing
//! components to log messages at various levels (trace, debug, info, warn,
//! error, critical).

use std::collections::{HashMap, HashSet};
use std::sync::Arc;

use crate::engine::ctx::Ctx;
use crate::engine::workload::WorkloadComponent;
use crate::plugin::HostPlugin;
use crate::wit::{WitInterface, WitWorld};
use anyhow::bail;

const PLUGIN_LOGGING_ID: &str = "wasi-logging";

mod bindings {
    crate::wasmtime::component::bindgen!({
        world: "logging",
        imports: { default: async | trappable },
    });
}

use bindings::wasi::logging::logging::Level;
use tokio::sync::RwLock;
use wasmtime::component::HasSelf;

type ComponentMap = Arc<RwLock<HashMap<String, ComponentInfo>>>;

#[derive(Default)]
pub struct TracingLogging {
    components: ComponentMap,
}

struct ComponentInfo {
    workload_name: String,
    workload_namespace: String,
    component_id: String,
}

impl bindings::wasi::logging::logging::Host for Ctx {
    async fn log(&mut self, level: Level, context: String, message: String) -> anyhow::Result<()> {
        let Some(plugin) = self.get_plugin::<TracingLogging>(PLUGIN_LOGGING_ID) else {
            bail!("TracingLogging plugin not found in context");
        };

        let workloads = plugin.components.read().await;
        let Some(ComponentInfo {
            workload_name,
            workload_namespace,
            component_id,
        }) = workloads.get(&self.component_id.to_string())
        else {
            bail!("Component not found in TracingLogging plugin");
        };
        match level {
            Level::Trace => {
                tracing::trace!(
                    workload.component_id = component_id,
                    workload.name = workload_name,
                    workload.namespace = workload_namespace,
                    context,
                    "{message}"
                )
            }
            Level::Debug => {
                tracing::debug!(
                    workload.component_id = component_id,
                    workload.name = workload_name,
                    workload.namespace = workload_namespace,
                    context,
                    "{message}"
                )
            }
            Level::Info => {
                tracing::info!(
                    workload.component_id = component_id,
                    workload.name = workload_name,
                    workload.namespace = workload_namespace,
                    context,
                    "{message}"
                )
            }
            Level::Warn => {
                tracing::warn!(
                    workload.component_id = component_id,
                    workload.name = workload_name,
                    workload.namespace = workload_namespace,
                    context,
                    "{message}"
                )
            }
            Level::Error => {
                tracing::error!(
                    workload.component_id = component_id,
                    workload.name = workload_name,
                    workload.namespace = workload_namespace,
                    context,
                    "{message}"
                )
            }
            Level::Critical => {
                tracing::error!(
                    workload.component_id = component_id,
                    workload.name = workload_name,
                    workload.namespace = workload_namespace,
                    context,
                    "{message}"
                )
            }
        };

        Ok(())
    }
}

#[async_trait::async_trait]
impl HostPlugin for TracingLogging {
    fn id(&self) -> &'static str {
        PLUGIN_LOGGING_ID
    }

    fn world(&self) -> WitWorld {
        WitWorld {
            imports: HashSet::from([WitInterface::from("wasi:logging/logging")]),
            ..Default::default()
        }
    }

    async fn on_component_bind(
        &self,
        component: &mut WorkloadComponent,
        interfaces: std::collections::HashSet<WitInterface>,
    ) -> anyhow::Result<()> {
        // Ensure exactly one interface: "wasi:logging/logging"
        let has_logging = interfaces
            .iter()
            .any(|i| i.namespace == "wasi" && i.package == "logging");

        if !has_logging {
            tracing::warn!(
                "TracingLoggingPlugin plugin requested for non-wasi:logging interface(s): {:?}",
                interfaces
            );
            return Ok(());
        }

        // Add `wasi:logging/logging` to the workload's linker
        bindings::wasi::logging::logging::add_to_linker::<_, HasSelf<Ctx>>(
            component.linker(),
            |ctx| ctx,
        )?;

        self.components.write().await.insert(
            component.id().to_string(),
            ComponentInfo {
                workload_name: component.workload_name().to_string(),
                workload_namespace: component.workload_namespace().to_string(),
                component_id: component.id().to_string(),
            },
        );

        Ok(())
    }
}

[if0ne]

Yes, this is a bug. In my opinion, when one component calls another component, the context of the caller component is used, not the callee component. That is why the plugin cannot be found, because the context of the http component is used.

[yoktobit]

Oh, wow, I was chasing that bug quite a few days now and now I see you are already on it! I tried to build a chain with http -> component -> component (with custom interface) -> wasmcloud:messaging/consumer/publish and it failed because the messaging plugin was not found, I already figured out that it was linked to the wrong component. I now tried it by checking out the PR, which works great for my case.