diff --git a/examples/rust/rendezvous/src/bin/client.rs b/examples/rust/rendezvous/src/bin/client.rs
index 36cf7f168a3..f5d6af5f6cb 100644
--- a/examples/rust/rendezvous/src/bin/client.rs
+++ b/examples/rust/rendezvous/src/bin/client.rs
@@ -5,7 +5,7 @@ use ockam_transport_udp::{UdpBindArguments, UdpBindOptions, UdpTransport, UDP};
 
 #[ockam_macros::node]
 async fn main(ctx: Context) -> Result<()> {
-    let udp = UdpTransport::create(&ctx)?;
+    let udp = UdpTransport::get_or_create(&ctx)?;
 
     let bind = udp
         .bind(UdpBindArguments::new(), UdpBindOptions::new())
diff --git a/examples/rust/rendezvous/src/bin/echo_server.rs b/examples/rust/rendezvous/src/bin/echo_server.rs
index 64fa8ea5d36..864ef318108 100644
--- a/examples/rust/rendezvous/src/bin/echo_server.rs
+++ b/examples/rust/rendezvous/src/bin/echo_server.rs
@@ -5,7 +5,7 @@ use ockam_transport_udp::{UdpBindArguments, UdpBindOptions, UdpTransport};
 
 #[ockam_macros::node]
 async fn main(ctx: Context) -> Result<()> {
-    let udp = UdpTransport::create(&ctx)?;
+    let udp = UdpTransport::get_or_create(&ctx)?;
     let bind = udp
         .bind(
             UdpBindArguments::new().with_bind_address("127.0.0.1:8000")?,
diff --git a/implementations/rust/ockam/ockam/tests/relay.rs b/implementations/rust/ockam/ockam/tests/relay.rs
index ea5d20f6c7a..8f4b0782f9d 100644
--- a/implementations/rust/ockam/ockam/tests/relay.rs
+++ b/implementations/rust/ockam/ockam/tests/relay.rs
@@ -37,7 +37,7 @@ async fn test2(ctx: &mut Context) -> Result<()> {
         .service_as_consumer(&tcp_listener_options.spawner_flow_control_id())
         .relay_as_consumer(&tcp_listener_options.spawner_flow_control_id());
     RelayService::create(ctx, "forwarding_service", options)?;
-    let cloud_tcp = TcpTransport::create(ctx)?;
+    let cloud_tcp = TcpTransport::get_or_create(ctx)?;
 
     let cloud_listener = cloud_tcp
         .listen("127.0.0.1:0", tcp_listener_options)
@@ -49,7 +49,7 @@ async fn test2(ctx: &mut Context) -> Result<()> {
     ctx.flow_controls()
         .add_consumer(&"echoer".into(), &tcp_options.flow_control_id());
 
-    let server_tcp = TcpTransport::create(ctx)?;
+    let server_tcp = TcpTransport::get_or_create(ctx)?;
     let cloud_connection = server_tcp
         .connect(cloud_listener.socket_string(), tcp_options)
         .await?;
@@ -57,7 +57,7 @@ async fn test2(ctx: &mut Context) -> Result<()> {
     let remote_info =
         RemoteRelay::create(ctx, cloud_connection.clone(), RemoteRelayOptions::new()).await?;
 
-    let client_tcp = TcpTransport::create(ctx)?;
+    let client_tcp = TcpTransport::get_or_create(ctx)?;
     let cloud_connection = client_tcp
         .connect(cloud_listener.socket_string(), TcpConnectionOptions::new())
         .await?;
@@ -82,7 +82,7 @@ async fn test3(ctx: &mut Context) -> Result<()> {
         .service_as_consumer(&tcp_listener_options.spawner_flow_control_id())
         .relay_as_consumer(&tcp_listener_options.spawner_flow_control_id());
     RelayService::create(ctx, "forwarding_service", options)?;
-    let cloud_tcp = TcpTransport::create(ctx)?;
+    let cloud_tcp = TcpTransport::get_or_create(ctx)?;
     let cloud_listener = cloud_tcp
         .listen("127.0.0.1:0", tcp_listener_options)
         .await?;
@@ -90,7 +90,7 @@ async fn test3(ctx: &mut Context) -> Result<()> {
     let tcp_options = TcpConnectionOptions::new();
     let server_tcp_flow_control_id = tcp_options.flow_control_id();
 
-    let server_tcp = TcpTransport::create(ctx)?;
+    let server_tcp = TcpTransport::get_or_create(ctx)?;
     let cloud_connection = server_tcp
         .connect(cloud_listener.socket_string(), tcp_options)
         .await?;
@@ -171,7 +171,7 @@ async fn test4(ctx: &mut Context) -> Result<()> {
         cloud_secure_channel_listener_options,
     )?;
 
-    let cloud_tcp = TcpTransport::create(ctx)?;
+    let cloud_tcp = TcpTransport::get_or_create(ctx)?;
     let cloud_listener = cloud_tcp
         .listen("127.0.0.1:0", cloud_tcp_listener_options)
         .await?;
@@ -187,7 +187,7 @@ async fn test4(ctx: &mut Context) -> Result<()> {
         &server_secure_channel_listener_options.spawner_flow_control_id(),
     );
 
-    let server_tcp = TcpTransport::create(ctx)?;
+    let server_tcp = TcpTransport::get_or_create(ctx)?;
     let cloud_server_connection = server_tcp
         .connect(cloud_listener.socket_string(), TcpConnectionOptions::new())
         .await?;
@@ -211,7 +211,7 @@ async fn test4(ctx: &mut Context) -> Result<()> {
         RemoteRelay::create(ctx, cloud_server_channel.clone(), RemoteRelayOptions::new()).await?;
 
     // Client
-    let client_tcp = TcpTransport::create(ctx)?;
+    let client_tcp = TcpTransport::get_or_create(ctx)?;
     let cloud_client_connection = client_tcp
         .connect(cloud_listener.socket_string(), TcpConnectionOptions::new())
         .await?;
diff --git a/implementations/rust/ockam/ockam_api/src/authority_node/authority.rs b/implementations/rust/ockam/ockam_api/src/authority_node/authority.rs
index 57615efc080..8cd99e06639 100644
--- a/implementations/rust/ockam/ockam_api/src/authority_node/authority.rs
+++ b/implementations/rust/ockam/ockam_api/src/authority_node/authority.rs
@@ -149,7 +149,7 @@ impl Authority {
         info!("started a secure channel listener with name '{listener_name}'");
 
         // Create a TCP listener and wait for incoming connections
-        let tcp = TcpTransport::create(ctx)?;
+        let tcp = TcpTransport::get_or_create(ctx)?;
 
         let listener = tcp
             .listen(
@@ -562,7 +562,7 @@ pub mod tests {
         caller: &Identifier,
     ) -> Result<AuthorityNodeClient> {
         let client = NodeManager::authority_node_client(
-            TcpTransport::create(ctx)?,
+            TcpTransport::get_or_create(ctx)?,
             secure_channels,
             authority_identifier,
             authority_route,
diff --git a/implementations/rust/ockam/ockam_api/src/cli_state/nodes.rs b/implementations/rust/ockam/ockam_api/src/cli_state/nodes.rs
index 6244330f92e..b66170641b8 100644
--- a/implementations/rust/ockam/ockam_api/src/cli_state/nodes.rs
+++ b/implementations/rust/ockam/ockam_api/src/cli_state/nodes.rs
@@ -23,8 +23,6 @@ use crate::config::lookup::InternetAddress;
 
 use crate::{fmt_warn, ConnectionStatus};
 
-pub const DEFAULT_NODE_NAME: &str = "_default_node_name";
-
 /// The methods below support the creation and update of local nodes
 impl CliState {
     /// Create a node, with some optional associated values, and start it
diff --git a/implementations/rust/ockam/ockam_api/src/logs/exporting_configuration.rs b/implementations/rust/ockam/ockam_api/src/logs/exporting_configuration.rs
index 4d622d12e48..0f95a8d4d8a 100644
--- a/implementations/rust/ockam/ockam_api/src/logs/exporting_configuration.rs
+++ b/implementations/rust/ockam/ockam_api/src/logs/exporting_configuration.rs
@@ -1,4 +1,4 @@
-use crate::cli_state::DEFAULT_NODE_NAME;
+use crate::cli_state::random_name;
 use crate::config::UrlVar;
 use crate::logs::default_values::*;
 use crate::logs::env_variables::*;
@@ -513,7 +513,7 @@ async fn make_secure_client(
         node
     } else {
         cli_state
-            .create_node_with_optional_identity(DEFAULT_NODE_NAME, &None)
+            .create_node_with_optional_identity(&random_name(), &None)
             .await?
     };
     let secure_channels = cli_state.secure_channels(&default_node.name()).await?;
@@ -521,7 +521,7 @@ async fn make_secure_client(
     Ok(SecureClient::new(
         secure_channels,
         None,
-        TcpTransport::create(ctx)?,
+        TcpTransport::get_or_create(ctx)?,
         project_route,
         Arc::new(TrustIdentifierPolicy::new(identifier)),
         &default_node.identifier(),
diff --git a/implementations/rust/ockam/ockam_api/src/logs/grpc_forwarder.rs b/implementations/rust/ockam/ockam_api/src/logs/grpc_forwarder.rs
index cb0be2a056f..ea72415bcc6 100644
--- a/implementations/rust/ockam/ockam_api/src/logs/grpc_forwarder.rs
+++ b/implementations/rust/ockam/ockam_api/src/logs/grpc_forwarder.rs
@@ -37,7 +37,7 @@ impl GrpcForwarder {
 
     /// Forward an http Request.
     /// We don't wait for a response here.
-    async fn forward_http_request(&mut self, request: http::Request<BoxBody>) -> Result<()> {
+    async fn forward_grpc_request(&mut self, request: http::Request<BoxBody>) -> Result<()> {
         self.ready().await.map_err(ApiError::core)?;
         let _ = self
             .channel
@@ -75,7 +75,7 @@ impl Worker for GrpcForwarder {
             let http_request = ockam_request.make_http_request().map_err(|e| {
                 ockam_core::Error::new(Origin::Api, Kind::Serialization, format!("{e:?}"))
             })?;
-            self.forward_http_request(http_request)
+            self.forward_grpc_request(http_request)
                 .await
                 .map_err(|e| ockam_core::Error::new(Origin::Api, Kind::Io, format!("{e:?}")))?;
         };
diff --git a/implementations/rust/ockam/ockam_api/src/logs/ockam_tonic_logs_client.rs b/implementations/rust/ockam/ockam_api/src/logs/ockam_tonic_logs_client.rs
index 9bd50c9f9c4..6dbfde95df1 100644
--- a/implementations/rust/ockam/ockam_api/src/logs/ockam_tonic_logs_client.rs
+++ b/implementations/rust/ockam/ockam_api/src/logs/ockam_tonic_logs_client.rs
@@ -134,7 +134,7 @@ mod tests {
             // wait until the forwarder node is up
             tokio::time::sleep(Duration::from_millis(100)).await;
             let secure_channels = create_secure_channels().await?;
-            let tcp_transport = TcpTransport::create(&ctx)?;
+            let tcp_transport = TcpTransport::get_or_create(&ctx)?;
             let secure_client = make_secure_client(port, secure_channels, tcp_transport).await?;
             let project_service =
                 SecureClientService::new(secure_client, &ctx, DefaultAddress::GRPC_FORWARDER);
diff --git a/implementations/rust/ockam/ockam_api/src/logs/ockam_tonic_traces_client.rs b/implementations/rust/ockam/ockam_api/src/logs/ockam_tonic_traces_client.rs
index 80ace283fe3..8bf2c7000ae 100644
--- a/implementations/rust/ockam/ockam_api/src/logs/ockam_tonic_traces_client.rs
+++ b/implementations/rust/ockam/ockam_api/src/logs/ockam_tonic_traces_client.rs
@@ -144,7 +144,7 @@ pub(crate) mod tests {
             // wait until the forwarder node is up
             tokio::time::sleep(Duration::from_millis(100)).await;
             let secure_channels = create_secure_channels().await?;
-            let tcp_transport = TcpTransport::create(&ctx)?;
+            let tcp_transport = TcpTransport::get_or_create(&ctx)?;
             let secure_client = make_secure_client(port, secure_channels, tcp_transport).await?;
             let project_service =
                 SecureClientService::new(secure_client, &ctx, DefaultAddress::GRPC_FORWARDER);
@@ -245,7 +245,7 @@ pub(crate) mod tests {
     }
 
     pub(crate) async fn start_tcp_listener(ctx: &Context, port: u16) -> Result<TcpListenerOptions> {
-        let tcp_transport = TcpTransport::create(ctx)?;
+        let tcp_transport = TcpTransport::get_or_create(ctx)?;
         let tcp_listener_options = TcpListenerOptions::new();
         let _tcp_listener = tcp_transport
             .listen(format!("127.0.0.1:{port}"), tcp_listener_options.clone())
diff --git a/implementations/rust/ockam/ockam_api/src/logs/secure_client_service.rs b/implementations/rust/ockam/ockam_api/src/logs/secure_client_service.rs
index 66d0fae7069..c78040fc9ae 100644
--- a/implementations/rust/ockam/ockam_api/src/logs/secure_client_service.rs
+++ b/implementations/rust/ockam/ockam_api/src/logs/secure_client_service.rs
@@ -18,7 +18,7 @@ use tonic::codegen::Service;
 /// SecureClient.
 ///
 /// The Context is an Option since because it is necessary to clone this struct and attempting
-/// to attempt a Context could fail if the current node is being shut down.
+/// to clone a Context could fail if the current node is being shut down.
 ///
 pub struct SecureClientService {
     secure_client: SecureClient,
diff --git a/implementations/rust/ockam/ockam_api/src/nodes/service/background_node_client.rs b/implementations/rust/ockam/ockam_api/src/nodes/service/background_node_client.rs
index daf6a6ef38d..ff2ac36076a 100644
--- a/implementations/rust/ockam/ockam_api/src/nodes/service/background_node_client.rs
+++ b/implementations/rust/ockam/ockam_api/src/nodes/service/background_node_client.rs
@@ -51,7 +51,7 @@ impl BackgroundNodeClient {
         cli_state: &CliState,
         node_name: &str,
     ) -> miette::Result<BackgroundNodeClient> {
-        let tcp_transport = TcpTransport::create(ctx).into_diagnostic()?;
+        let tcp_transport = TcpTransport::get_or_create(ctx).into_diagnostic()?;
         BackgroundNodeClient::new(&tcp_transport, cli_state, node_name)
     }
 
diff --git a/implementations/rust/ockam/ockam_api/src/nodes/service/in_memory_node.rs b/implementations/rust/ockam/ockam_api/src/nodes/service/in_memory_node.rs
index 67cb5e7d0dc..cfe721b6076 100644
--- a/implementations/rust/ockam/ockam_api/src/nodes/service/in_memory_node.rs
+++ b/implementations/rust/ockam/ockam_api/src/nodes/service/in_memory_node.rs
@@ -143,7 +143,7 @@ impl InMemoryNode {
     ) -> miette::Result<InMemoryNode> {
         let defaults = NodeManagerDefaults::default();
 
-        let tcp = TcpTransport::create(ctx).into_diagnostic()?;
+        let tcp = TcpTransport::get_or_create(ctx).into_diagnostic()?;
         let tcp_listener = tcp
             .listen(
                 defaults.tcp_listener_address.as_str(),
diff --git a/implementations/rust/ockam/ockam_api/src/test_utils/mod.rs b/implementations/rust/ockam/ockam_api/src/test_utils/mod.rs
index de5cd0b2f21..fdc8d187c82 100644
--- a/implementations/rust/ockam/ockam_api/src/test_utils/mod.rs
+++ b/implementations/rust/ockam/ockam_api/src/test_utils/mod.rs
@@ -59,7 +59,7 @@ pub async fn start_manager_for_tests(
     bind_address: Option<&str>,
     trust_options: Option<NodeManagerTrustOptions>,
 ) -> Result<NodeManagerHandle> {
-    let tcp = TcpTransport::create(context)?;
+    let tcp = TcpTransport::get_or_create(context)?;
     let tcp_listener = tcp
         .listen(
             bind_address.unwrap_or("127.0.0.1:0"),
diff --git a/implementations/rust/ockam/ockam_api/tests/common/common.rs b/implementations/rust/ockam/ockam_api/tests/common/common.rs
index 79bd9d7b15d..f99b79d56b3 100644
--- a/implementations/rust/ockam/ockam_api/tests/common/common.rs
+++ b/implementations/rust/ockam/ockam_api/tests/common/common.rs
@@ -127,7 +127,7 @@ pub async fn start_authority(
             .await?;
 
         let authority_node_client = NodeManager::authority_node_client(
-            TcpTransport::create(ctx)?,
+            TcpTransport::get_or_create(ctx)?,
             secure_channels.clone(),
             &configuration.identifier,
             &MultiAddr::try_from("/secure/api")?,
diff --git a/implementations/rust/ockam/ockam_app_lib/src/state/mod.rs b/implementations/rust/ockam/ockam_app_lib/src/state/mod.rs
index 9b16da86c89..2b00cee0ba4 100644
--- a/implementations/rust/ockam/ockam_app_lib/src/state/mod.rs
+++ b/implementations/rust/ockam/ockam_app_lib/src/state/mod.rs
@@ -686,7 +686,7 @@ pub(crate) async fn make_node_manager(
     ctx: Arc<Context>,
     cli_state: &CliState,
 ) -> miette::Result<Arc<InMemoryNode>> {
-    let tcp = TcpTransport::create(&ctx).into_diagnostic()?;
+    let tcp = TcpTransport::get_or_create(&ctx).into_diagnostic()?;
     let options = TcpListenerOptions::new();
     let listener = tcp
         .listen(&"127.0.0.1:0", options)
diff --git a/implementations/rust/ockam/ockam_command/src/node/create.rs b/implementations/rust/ockam/ockam_command/src/node/create.rs
index 576ee26caa8..65d7fb89f5f 100644
--- a/implementations/rust/ockam/ockam_command/src/node/create.rs
+++ b/implementations/rust/ockam/ockam_command/src/node/create.rs
@@ -30,6 +30,7 @@ pub mod config;
 pub mod foreground;
 pub mod node_callback;
 
+const DEFAULT_NODE_NAME: &str = "_default_node_name";
 const LONG_ABOUT: &str = include_str!("./static/create/long_about.txt");
 const AFTER_LONG_HELP: &str = include_str!("./static/create/after_long_help.txt");
 
diff --git a/implementations/rust/ockam/ockam_command/src/node/create/foreground.rs b/implementations/rust/ockam/ockam_command/src/node/create/foreground.rs
index d7436b82e61..ea2c4ef05db 100644
--- a/implementations/rust/ockam/ockam_command/src/node/create/foreground.rs
+++ b/implementations/rust/ockam/ockam_command/src/node/create/foreground.rs
@@ -1,3 +1,4 @@
+use crate::node::create::DEFAULT_NODE_NAME;
 use crate::node::node_callback::NodeCallback;
 use crate::node::CreateCommand;
 use crate::service::config::ControlApiNodeResolution;
@@ -8,7 +9,7 @@ use miette::IntoDiagnostic;
 use ockam::tcp::{TcpListenerOptions, TcpTransport};
 use ockam::udp::{UdpBindArguments, UdpBindOptions, UdpTransport};
 use ockam::{Address, Context};
-use ockam_api::cli_state::{random_name, DEFAULT_NODE_NAME};
+use ockam_api::cli_state::random_name;
 use ockam_api::colors::color_primary;
 use ockam_api::control_api::frontend::NodeResolution;
 use ockam_api::fmt_log;
@@ -47,7 +48,7 @@ impl CreateCommand {
             .into_diagnostic()?;
 
         // Create TCP transport
-        let tcp = TcpTransport::create(ctx).into_diagnostic()?;
+        let tcp = TcpTransport::get_or_create(ctx).into_diagnostic()?;
         let tcp_listener = tcp
             .listen(&self.tcp_listener_address, TcpListenerOptions::new())
             .await
@@ -74,7 +75,7 @@ impl CreateCommand {
         debug!("node info persisted {node_info:?}");
 
         let udp_options = if self.udp {
-            let udp = UdpTransport::create(ctx).into_diagnostic()?;
+            let udp = UdpTransport::get_or_create(ctx).into_diagnostic()?;
             let options = UdpBindOptions::new();
             let flow_control_id = options.flow_control_id();
             udp.bind(
diff --git a/implementations/rust/ockam/ockam_command/src/rendezvous/create/foreground.rs b/implementations/rust/ockam/ockam_command/src/rendezvous/create/foreground.rs
index 622166e2f08..0800c651ba3 100644
--- a/implementations/rust/ockam/ockam_command/src/rendezvous/create/foreground.rs
+++ b/implementations/rust/ockam/ockam_command/src/rendezvous/create/foreground.rs
@@ -25,7 +25,7 @@ impl CreateCommand {
 
         RendezvousService::start(ctx, DefaultAddress::RENDEZVOUS_SERVICE).into_diagnostic()?;
 
-        let udp = UdpTransport::create(ctx).into_diagnostic()?;
+        let udp = UdpTransport::get_or_create(ctx).into_diagnostic()?;
         let bind = udp
             .bind(
                 UdpBindArguments::new().with_bind_socket_address(udp_address),
diff --git a/implementations/rust/ockam/ockam_command/src/rendezvous/get_my_address.rs b/implementations/rust/ockam/ockam_command/src/rendezvous/get_my_address.rs
index 9a829d7802d..58fa1633bd8 100644
--- a/implementations/rust/ockam/ockam_command/src/rendezvous/get_my_address.rs
+++ b/implementations/rust/ockam/ockam_command/src/rendezvous/get_my_address.rs
@@ -20,7 +20,7 @@ impl Command for GetMyAddressCommand {
     const NAME: &'static str = "rendezvous get-my-address";
 
     async fn run(self, ctx: &Context, opts: CommandGlobalOpts) -> crate::Result<()> {
-        let udp = UdpTransport::create(ctx)?;
+        let udp = UdpTransport::get_or_create(ctx)?;
         let bind = udp
             .bind(
                 UdpBindArguments::new().with_bind_address("0.0.0.0:0")?,
diff --git a/implementations/rust/ockam/ockam_identity/tests/ciphertext_message_flow_auth.rs b/implementations/rust/ockam/ockam_identity/tests/ciphertext_message_flow_auth.rs
index 2fc79175c1e..a9a9539402f 100644
--- a/implementations/rust/ockam/ockam_identity/tests/ciphertext_message_flow_auth.rs
+++ b/implementations/rust/ockam/ockam_identity/tests/ciphertext_message_flow_auth.rs
@@ -15,12 +15,12 @@ mod common;
 // Bob: TCP listener + Secure Channel listener
 #[ockam_macros::test]
 async fn test1(ctx: &mut Context) -> Result<()> {
-    let tcp_bob = TcpTransport::create(ctx)?;
+    let tcp_bob = TcpTransport::get_or_create(ctx)?;
     let listener = tcp_bob
         .listen("127.0.0.1:0", TcpListenerOptions::new())
         .await?;
 
-    let tcp_alice = TcpTransport::create(ctx)?;
+    let tcp_alice = TcpTransport::get_or_create(ctx)?;
     let connection_to_bob = tcp_alice
         .connect(listener.socket_string(), TcpConnectionOptions::new())
         .await?;
diff --git a/implementations/rust/ockam/ockam_identity/tests/credentials_refresh.rs b/implementations/rust/ockam/ockam_identity/tests/credentials_refresh.rs
index 702489e2062..c435ef0c038 100644
--- a/implementations/rust/ockam/ockam_identity/tests/credentials_refresh.rs
+++ b/implementations/rust/ockam/ockam_identity/tests/credentials_refresh.rs
@@ -210,7 +210,7 @@ async fn init(
     ttl: Duration,
     timing_options: RemoteCredentialRetrieverTimingOptions,
 ) -> Result<InitResult> {
-    let tcp = TcpTransport::create(ctx)?;
+    let tcp = TcpTransport::get_or_create(ctx)?;
 
     let client_secure_channels = secure_channels().await?;
     let authority_secure_channels = secure_channels().await?;
diff --git a/implementations/rust/ockam/ockam_identity/tests/update_route.rs b/implementations/rust/ockam/ockam_identity/tests/update_route.rs
index 51569911dad..e7547c46c55 100644
--- a/implementations/rust/ockam/ockam_identity/tests/update_route.rs
+++ b/implementations/rust/ockam/ockam_identity/tests/update_route.rs
@@ -75,7 +75,7 @@ async fn test_update_decryptor_route(ctx: &mut Context) -> Result<()> {
 
 #[ockam_macros::test]
 async fn test_update_decryptor_route_tcp(ctx: &mut Context) -> Result<()> {
-    let tcp = TcpTransport::create(ctx)?;
+    let tcp = TcpTransport::get_or_create(ctx)?;
 
     let tcp_listener1 = tcp.listen("127.0.0.1:0", TcpListenerOptions::new()).await?;
     let tcp_listener2 = tcp.listen("127.0.0.1:0", TcpListenerOptions::new()).await?;
diff --git a/implementations/rust/ockam/ockam_transport_tcp/src/transport/connection.rs b/implementations/rust/ockam/ockam_transport_tcp/src/transport/connection.rs
index b1a2f91f3ec..ddfbb455ffa 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/src/transport/connection.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/src/transport/connection.rs
@@ -98,7 +98,7 @@ impl TcpTransport {
     /// # use ockam_node::Context;
     /// # use ockam_core::Result;
     /// # async fn test(ctx: Context) -> Result<()> {
-    /// let tcp = TcpTransport::create(&ctx)?;
+    /// let tcp = TcpTransport::get_or_create(&ctx)?;
     /// tcp.listen("127.0.0.1:8000", TcpListenerOptions::new()).await?; // Listen on port 8000
     /// let connection = tcp.connect("127.0.0.1:5000", TcpConnectionOptions::new()).await?; // and connect to port 5000
     /// # Ok(()) }
diff --git a/implementations/rust/ockam/ockam_transport_tcp/src/transport/lifecycle.rs b/implementations/rust/ockam/ockam_transport_tcp/src/transport/lifecycle.rs
index 3f658e48705..01a30c61404 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/src/transport/lifecycle.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/src/transport/lifecycle.rs
@@ -16,11 +16,11 @@ impl TcpTransport {
     /// # use ockam_node::Context;
     /// # use ockam_core::Result;
     /// # async fn test(ctx: Context) -> Result<()> {
-    /// let tcp = TcpTransport::create(&ctx)?;
+    /// let tcp = TcpTransport::get_or_create(&ctx)?;
     /// # Ok(()) }
     /// ```
-    #[instrument(name = "create tcp transport", skip_all)]
-    pub fn create(ctx: &Context) -> Result<Arc<TcpTransport>> {
+    #[instrument(name = "get or create tcp transport", skip_all)]
+    pub fn get_or_create(ctx: &Context) -> Result<Arc<TcpTransport>> {
         // don't register the TCP transport twice
         match ctx.get_transport(TCP) {
             Some(t) => {
@@ -166,7 +166,7 @@ mod tests {
 
     #[ockam_macros::test]
     async fn test_resolve_address(ctx: &mut Context) -> Result<()> {
-        let tcp = TcpTransport::create(ctx)?;
+        let tcp = TcpTransport::get_or_create(ctx)?;
         let tcp_address = "127.0.0.1:0";
         let initial_workers = ctx.list_workers()?;
         let listener = TcpListener::bind(tcp_address)
@@ -205,7 +205,7 @@ mod tests {
 
     #[ockam_macros::test]
     async fn test_resolve_route_with_dns_address(ctx: &mut Context) -> Result<()> {
-        let tcp = TcpTransport::create(ctx)?;
+        let tcp = TcpTransport::get_or_create(ctx)?;
         let tcp_address = "127.0.0.1:0";
         let listener = TcpListener::bind(tcp_address)
             .await
diff --git a/implementations/rust/ockam/ockam_transport_tcp/src/transport/listener.rs b/implementations/rust/ockam/ockam_transport_tcp/src/transport/listener.rs
index 1f6954fedd1..14e4b1151ee 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/src/transport/listener.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/src/transport/listener.rs
@@ -69,7 +69,7 @@ impl TcpTransport {
     /// # use ockam_node::Context;
     /// # use ockam_core::Result;
     /// # async fn test(ctx: Context) -> Result<()> {
-    /// let tcp = TcpTransport::create(&ctx)?;
+    /// let tcp = TcpTransport::get_or_create(&ctx)?;
     /// tcp.listen("127.0.0.1:8000", TcpListenerOptions::new()).await?;
     /// # Ok(()) }
     pub async fn listen(
diff --git a/implementations/rust/ockam/ockam_transport_tcp/src/transport/mod.rs b/implementations/rust/ockam/ockam_transport_tcp/src/transport/mod.rs
index 37dc3b140ad..f77232b062e 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/src/transport/mod.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/src/transport/mod.rs
@@ -20,7 +20,7 @@ use ockam_node::{Context, HasContext};
 ///
 /// Be aware that only one `TcpTransport` can exist per node, as it
 /// registers itself as a router for the `TCP` address type.  Multiple
-/// calls to [`TcpTransport::create`](crate::TcpTransport::create)
+/// calls to [`TcpTransport::create`](crate::TcpTransport::get_or_create)
 /// will fail.
 ///
 /// To listen for incoming connections use
@@ -36,7 +36,7 @@ use ockam_node::{Context, HasContext};
 /// # use ockam_node::Context;
 /// # use ockam_core::Result;
 /// # async fn test(ctx: Context) -> Result<()> {
-/// let tcp = TcpTransport::create(&ctx)?;
+/// let tcp = TcpTransport::get_or_create(&ctx)?;
 /// tcp.listen("127.0.0.1:8000", TcpListenerOptions::new()).await?; // Listen on port 8000
 /// tcp.connect("127.0.0.1:5000", TcpConnectionOptions::new()).await?; // And connect to port 5000
 /// # Ok(()) }
@@ -49,7 +49,7 @@ use ockam_node::{Context, HasContext};
 /// # use ockam_node::Context;
 /// # use ockam_core::Result;
 /// # async fn test(ctx: Context) -> Result<()> {
-/// let tcp = TcpTransport::create(&ctx)?;
+/// let tcp = TcpTransport::get_or_create(&ctx)?;
 /// tcp.listen("127.0.0.1:8000", TcpListenerOptions::new()).await?; // Listen on port 8000
 /// tcp.listen("127.0.0.1:9000", TcpListenerOptions::new()).await?; // Listen on port 9000
 /// # Ok(()) }
@@ -80,7 +80,7 @@ impl TcpTransport {
 pub trait TcpTransportExtension: HasContext {
     /// Create a TCP transport
     fn create_tcp_transport(&self) -> Result<Arc<TcpTransport>> {
-        TcpTransport::create(self.get_context())
+        TcpTransport::get_or_create(self.get_context())
     }
 }
 
diff --git a/implementations/rust/ockam/ockam_transport_tcp/src/transport/portals.rs b/implementations/rust/ockam/ockam_transport_tcp/src/transport/portals.rs
index 91bf53a325e..30c5f0602d7 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/src/transport/portals.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/src/transport/portals.rs
@@ -23,7 +23,7 @@ impl TcpTransport {
     /// # async fn test(ctx: Context) -> Result<()> {
     /// let route_path = route!["outlet"];
     ///
-    /// let tcp = TcpTransport::create(&ctx)?;
+    /// let tcp = TcpTransport::get_or_create(&ctx)?;
     /// let address: Address = "inlet".into();
     /// tcp.create_inlet(address.clone(), route_path, TcpInletOptions::new()).await?;
     /// # tcp.stop_inlet(&address)?;
@@ -56,7 +56,7 @@ impl TcpTransport {
     /// # async fn test(ctx: Context) -> Result<()> {
     /// let route = route!["outlet"];
     ///
-    /// let tcp = TcpTransport::create(&ctx)?;
+    /// let tcp = TcpTransport::get_or_create(&ctx)?;
     /// let address: Address = "inlet".into();
     /// tcp.create_inlet(address.clone(), route, TcpInletOptions::new()).await?;
     /// tcp.stop_inlet(&address)?;
@@ -83,7 +83,7 @@ impl TcpTransport {
     ///
     /// async fn test(ctx: Context) -> Result<()> {
     ///
-    /// let tcp = TcpTransport::create(&ctx)?;
+    /// let tcp = TcpTransport::get_or_create(&ctx)?;
     /// let address: Address = "outlet".into();
     /// tcp.create_outlet(address.clone(), HostnamePort::new("localhost", 9000)?, TcpOutletOptions::new())?;
     /// # tcp.stop_outlet(&address)?;
@@ -116,7 +116,7 @@ impl TcpTransport {
     ///
     /// async fn test(ctx: Context) -> Result<()> {
     ///
-    /// let tcp = TcpTransport::create(&ctx)?;
+    /// let tcp = TcpTransport::get_or_create(&ctx)?;
     /// let address: Address = "outlet".into();
     /// tcp.create_outlet(address.clone(), HostnamePort::new("127.0.0.1", 5000)?, TcpOutletOptions::new())?;
     /// tcp.stop_outlet(&address)?;
diff --git a/implementations/rust/ockam/ockam_transport_tcp/tests/ebpf_portal.rs b/implementations/rust/ockam/ockam_transport_tcp/tests/ebpf_portal.rs
index 257d95abecc..cdcbe525c6d 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/tests/ebpf_portal.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/tests/ebpf_portal.rs
@@ -57,7 +57,7 @@ mod tests {
     #[ockam_macros::test(timeout = 5000)]
     #[ignore] // Requires root and capabilities
     async fn privileged_portal__standard_flow__should_succeed(ctx: &mut Context) -> Result<()> {
-        let tcp = TcpTransport::create(ctx)?;
+        let tcp = TcpTransport::get_or_create(ctx)?;
 
         let payload1 = generate_binary();
         let payload2 = generate_binary();
diff --git a/implementations/rust/ockam/ockam_transport_tcp/tests/interceptor.rs b/implementations/rust/ockam/ockam_transport_tcp/tests/interceptor.rs
index 93776c104c0..47f70ef1bc1 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/tests/interceptor.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/tests/interceptor.rs
@@ -46,7 +46,7 @@ impl PortalInterceptorFactory for MockPortalInterceptorFactory {
 async fn setup(
     context: &mut Context,
 ) -> ockam_core::Result<(String, TcpListener, Arc<MockPortalInterceptor>)> {
-    let tcp = TcpTransport::create(context)?;
+    let tcp = TcpTransport::get_or_create(context)?;
 
     let listener = {
         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
diff --git a/implementations/rust/ockam/ockam_transport_tcp/tests/keepalive.rs b/implementations/rust/ockam/ockam_transport_tcp/tests/keepalive.rs
index e2003b14c7d..e33ab569574 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/tests/keepalive.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/tests/keepalive.rs
@@ -8,7 +8,7 @@ use tracing::info;
 #[ignore]
 #[ockam_macros::test(timeout = 400000)]
 async fn tcp_keepalive_test(ctx: &mut Context) -> Result<()> {
-    let tcp = TcpTransport::create(ctx)?;
+    let tcp = TcpTransport::get_or_create(ctx)?;
 
     let message: String = rand::thread_rng()
         .sample_iter(&rand::distributions::Alphanumeric)
diff --git a/implementations/rust/ockam/ockam_transport_tcp/tests/lifecycle.rs b/implementations/rust/ockam/ockam_transport_tcp/tests/lifecycle.rs
index fffb66d6110..56147cbceb6 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/tests/lifecycle.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/tests/lifecycle.rs
@@ -13,7 +13,7 @@ async fn tcp_lifecycle__two_connections__should_both_work(ctx: &mut Context) ->
         .add_consumer(&"echoer".into(), &options.spawner_flow_control_id());
     ctx.start_worker("echoer", Echoer)?;
 
-    let transport = TcpTransport::create(ctx)?;
+    let transport = TcpTransport::get_or_create(ctx)?;
     let listener = transport.listen("127.0.0.1:0", options).await?;
 
     let msg1: String = rand::thread_rng()
@@ -55,7 +55,7 @@ async fn tcp_lifecycle__disconnect__should_stop_worker(ctx: &mut Context) -> Res
         .add_consumer(&"echoer".into(), &options.spawner_flow_control_id());
     ctx.start_worker("echoer", Echoer)?;
 
-    let transport = TcpTransport::create(ctx)?;
+    let transport = TcpTransport::get_or_create(ctx)?;
     let listener = transport.listen("127.0.0.1:0", options).await?;
 
     let msg1: String = rand::thread_rng()
@@ -121,7 +121,7 @@ async fn tcp_lifecycle__stop_listener__should_stop_accepting_connections(
 
     ctx.start_worker("echoer", Echoer)?;
 
-    let transport = TcpTransport::create(ctx)?;
+    let transport = TcpTransport::get_or_create(ctx)?;
     let listener = transport.listen("127.0.0.1:0", options).await?;
 
     let msg1: String = rand::thread_rng()
diff --git a/implementations/rust/ockam/ockam_transport_tcp/tests/portal.rs b/implementations/rust/ockam/ockam_transport_tcp/tests/portal.rs
index 7f78d6e1d37..3f0e98a4677 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/tests/portal.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/tests/portal.rs
@@ -13,7 +13,7 @@ use ockam_transport_tcp::{
 const LENGTH: usize = 32;
 
 async fn setup(ctx: &Context, skip_handshake: bool) -> Result<(String, TcpListener)> {
-    let tcp = TcpTransport::create(ctx)?;
+    let tcp = TcpTransport::get_or_create(ctx)?;
 
     let listener = {
         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
@@ -170,7 +170,7 @@ async fn portal__tcp_connection__should_succeed__impl(
     let options = TcpListenerOptions::new();
     let outlet_flow_control_id = options.spawner_flow_control_id();
 
-    let tcp = TcpTransport::create(ctx)?;
+    let tcp = TcpTransport::get_or_create(ctx)?;
 
     let listener = tcp.listen("127.0.0.1:0", options).await?;
 
@@ -248,7 +248,7 @@ async fn portal__tcp_connection_with_invalid_message_flow__should_not_succeed__i
 
     let options = TcpListenerOptions::new();
 
-    let tcp = TcpTransport::create(ctx)?;
+    let tcp = TcpTransport::get_or_create(ctx)?;
 
     let tcp_listener = tcp.listen("127.0.0.1:0", options).await?;
 
@@ -318,7 +318,7 @@ async fn portal__update_route__should_succeed__impl(
     let payload1 = generate_binary();
     let payload2 = generate_binary();
 
-    let tcp = TcpTransport::create(ctx)?;
+    let tcp = TcpTransport::get_or_create(ctx)?;
 
     let listener_outlet = TcpListener::bind("127.0.0.1:0").await.unwrap();
     let listener_node = tcp.listen("127.0.0.1:0", TcpListenerOptions::new()).await?;
diff --git a/implementations/rust/ockam/ockam_transport_tcp/tests/send_receive.rs b/implementations/rust/ockam/ockam_transport_tcp/tests/send_receive.rs
index f3c7aa06b47..5505917b115 100644
--- a/implementations/rust/ockam/ockam_transport_tcp/tests/send_receive.rs
+++ b/implementations/rust/ockam/ockam_transport_tcp/tests/send_receive.rs
@@ -11,7 +11,7 @@ async fn send_receive(ctx: &mut Context) -> Result<()> {
         .add_consumer(&"echoer".into(), &options.spawner_flow_control_id());
     ctx.start_worker("echoer", Echoer)?;
 
-    let transport = TcpTransport::create(ctx)?;
+    let transport = TcpTransport::get_or_create(ctx)?;
     let listener = transport.listen("127.0.0.1:0", options).await?;
 
     let addr = transport
diff --git a/implementations/rust/ockam/ockam_transport_udp/src/puncture/rendezvous_service/rendezvous.rs b/implementations/rust/ockam/ockam_transport_udp/src/puncture/rendezvous_service/rendezvous.rs
index dd81c6c2f8c..3010cff32ff 100644
--- a/implementations/rust/ockam/ockam_transport_udp/src/puncture/rendezvous_service/rendezvous.rs
+++ b/implementations/rust/ockam/ockam_transport_udp/src/puncture/rendezvous_service/rendezvous.rs
@@ -20,7 +20,7 @@ use tracing::{debug, info, warn};
 ///
 /// // Start a Rendezvous service with address 'rendezvous' and listen on UDP port 4000
 /// RendezvousService::start(&ctx, "rendezvous")?;
-/// let udp = UdpTransport::create(&ctx)?;
+/// let udp = UdpTransport::get_or_create(&ctx)?;
 /// let bind = udp.bind(UdpBindArguments::new().with_bind_address("0.0.0.0:4000")?, UdpBindOptions::new()).await?;
 /// ctx.flow_controls().add_consumer(&"rendezvous".into(), bind.flow_control_id());
 /// # Ok(()) }
@@ -181,7 +181,7 @@ mod tests {
     /// Helper
     async fn test_setup(ctx: &mut Context) -> Result<(Route, UdpBind)> {
         // Create transport, start rendezvous service, start echo service and listen
-        let transport = UdpTransport::create(ctx)?;
+        let transport = UdpTransport::get_or_create(ctx)?;
         RendezvousService::start(ctx, "rendezvous")?;
 
         let udp_bind = transport
diff --git a/implementations/rust/ockam/ockam_transport_udp/src/transport/lifecycle.rs b/implementations/rust/ockam/ockam_transport_udp/src/transport/lifecycle.rs
index 84a20b3256b..79010370c78 100644
--- a/implementations/rust/ockam/ockam_transport_udp/src/transport/lifecycle.rs
+++ b/implementations/rust/ockam/ockam_transport_udp/src/transport/lifecycle.rs
@@ -17,11 +17,11 @@ impl UdpTransport {
     /// # use ockam_node::Context;
     /// # use ockam_core::Result;
     /// # async fn test(ctx: Context) -> Result<()> {
-    /// let udp = UdpTransport::create(&ctx)?;
+    /// let udp = UdpTransport::get_or_create(&ctx)?;
     /// # Ok(()) }
     /// ```
-    #[instrument(name = "create udp transport", skip_all)]
-    pub fn create(ctx: &Context) -> Result<Arc<UdpTransport>> {
+    #[instrument(name = "get or create udp transport", skip_all)]
+    pub fn get_or_create(ctx: &Context) -> Result<Arc<UdpTransport>> {
         // don't register the UDP transport twice
         match ctx.get_transport(UDP) {
             Some(t) => {
@@ -102,7 +102,7 @@ mod tests {
 
     #[ockam_macros::test]
     async fn test_resolve_address(ctx: &mut Context) -> Result<()> {
-        let udp = UdpTransport::create(ctx)?;
+        let udp = UdpTransport::get_or_create(ctx)?;
         let udp_address = "127.0.0.1:0";
         let initial_workers = ctx.list_workers()?;
         let socket = UdpSocket::bind(udp_address)
@@ -134,7 +134,7 @@ mod tests {
 
     #[ockam_macros::test]
     async fn test_resolve_route_with_dns_address(ctx: &mut Context) -> Result<()> {
-        let udp = UdpTransport::create(ctx)?;
+        let udp = UdpTransport::get_or_create(ctx)?;
         let udp_address = "127.0.0.1:0";
         let socket = UdpSocket::bind(udp_address)
             .await
diff --git a/implementations/rust/ockam/ockam_transport_udp/src/transport/mod.rs b/implementations/rust/ockam/ockam_transport_udp/src/transport/mod.rs
index 67678f41515..d01125322ca 100644
--- a/implementations/rust/ockam/ockam_transport_udp/src/transport/mod.rs
+++ b/implementations/rust/ockam/ockam_transport_udp/src/transport/mod.rs
@@ -21,7 +21,7 @@ pub struct UdpTransport {
 pub trait UdpTransportExtension: HasContext {
     /// Create a UDP transport
     async fn create_udp_transport(&self) -> Result<Arc<UdpTransport>> {
-        UdpTransport::create(self.get_context())
+        UdpTransport::get_or_create(self.get_context())
     }
 }
 
diff --git a/implementations/rust/ockam/ockam_transport_udp/tests/tests.rs b/implementations/rust/ockam/ockam_transport_udp/tests/tests.rs
index 8f515d2f39f..c30e2bbf12d 100644
--- a/implementations/rust/ockam/ockam_transport_udp/tests/tests.rs
+++ b/implementations/rust/ockam/ockam_transport_udp/tests/tests.rs
@@ -16,7 +16,7 @@ const TIMEOUT: Duration = Duration::from_secs(5);
 #[ockam_macros::test]
 async fn reply_from_correct_server_port(ctx: &mut Context) -> Result<()> {
     // Transport
-    let transport = UdpTransport::create(ctx)?;
+    let transport = UdpTransport::get_or_create(ctx)?;
 
     // Listener
     ctx.start_worker("echoer", Echoer::new(true))?;
@@ -80,7 +80,7 @@ async fn recover_from_sender_error(ctx: &mut Context) -> Result<()> {
     debug!("addr_nok = {:?}", addr_nok);
 
     // Transport
-    let transport = UdpTransport::create(ctx)?;
+    let transport = UdpTransport::get_or_create(ctx)?;
 
     // Listener
     ctx.start_worker("echoer", Echoer::new(true))?;
@@ -129,7 +129,7 @@ async fn send_from_same_client_port(ctx: &mut Context) -> Result<()> {
     debug!("bind_addrs = {:?}", bind_addrs);
 
     // Transport
-    let transport = UdpTransport::create(ctx)?;
+    let transport = UdpTransport::get_or_create(ctx)?;
 
     // Listeners
     // Note: it is the Echoer which is checking the UDP ports for this test
@@ -174,7 +174,7 @@ async fn send_from_same_client_port(ctx: &mut Context) -> Result<()> {
 #[ockam_macros::test]
 async fn send_receive_arbitrary_udp_peer(ctx: &mut Context) -> Result<()> {
     // Transport
-    let transport = UdpTransport::create(ctx)?;
+    let transport = UdpTransport::get_or_create(ctx)?;
 
     ctx.start_worker("echoer", Echoer::new(true))?;
     let bind1 = transport
@@ -240,7 +240,7 @@ async fn send_receive_arbitrary_udp_peer(ctx: &mut Context) -> Result<()> {
 #[ockam_macros::test]
 async fn send_receive_one_known_udp_peer(ctx: &mut Context) -> Result<()> {
     // Transport
-    let transport = UdpTransport::create(ctx)?;
+    let transport = UdpTransport::get_or_create(ctx)?;
 
     ctx.start_worker("echoer", Echoer::new(false))?;
     let bind1 = transport
@@ -308,7 +308,7 @@ async fn send_receive_two_known_udp_peers(ctx: &mut Context) -> Result<()> {
     debug!("bind_addrs = {:?}", bind_addrs);
 
     // Transport
-    let transport = UdpTransport::create(ctx)?;
+    let transport = UdpTransport::get_or_create(ctx)?;
 
     ctx.start_worker("echoer", Echoer::new(false))?;
     let bind1 = transport
@@ -379,7 +379,7 @@ async fn send_receive_large_message(ctx: &mut Context) -> Result<()> {
     debug!("bind_addrs = {:?}", bind_addrs);
 
     // Transport
-    let transport = UdpTransport::create(ctx)?;
+    let transport = UdpTransport::get_or_create(ctx)?;
 
     ctx.start_worker("echoer", Echoer::new(false))?;
     let bind1 = transport
diff --git a/implementations/rust/telemetry.md b/implementations/rust/telemetry.md
index d2a217b5109..0ab07565338 100644
--- a/implementations/rust/telemetry.md
+++ b/implementations/rust/telemetry.md
@@ -43,7 +43,8 @@ The value of `grpc_endpoint` must be set to the endpoint of an accessible OpenTe
 
 ## Sending telemetry data directly via a secure channel to the authority node
 
-This behaviour is controlled by the `OCKAM_TELEMETRY_EXPORT_VIA_PROJECT` environment variable (the default is `false`).
+This behaviour is controlled by the `OCKAM_TELEMETRY_EXPORT_VIA_AUTHORITY` environment variable (the default is
+`false`).
 
 This mode is only active if a default project can be detected locally and is accessible via a secure channel.
 Then, the telemetry data is sent as Ockam messages to the project's authority node and forwarded to the collector.
@@ -58,8 +59,9 @@ the collector endpoint URL, for example `http://opentelemetry-collector:4317`.
 This behaviour is controlled by the setting of two environment variables:
 
 - `OCKAM_TELEMETRY_EXPORT_NODE_ROUTE` a route to the node to connect. For example:
-  `/dnsaddr/localhost/tcp/4000/secure/api`. Note that the presence of `secure/api` in the address is going to trigger
-  the creation of a secure channel.
+  `/dnsaddr/localhost/tcp/4000/secure/api`. Note that the presence of `secure/api` in the address is what's triggering
+  the creation of a secure channel and allows a node to send telemetry data without having to expose an OpenTelemetry
+  collector residing in your private network.
 - `OCKAM_TELEMETRY_EXPORT_NODE_IDENTIFIER` the identifier of the node that we are connecting to.
 - `OCKAM_TELEMETRY_EXPORT_NODE_FORWARDER_SERVICE` the address of the `GrpcForwarder` service started on the remote node.
   The default is `grpc_forwarder` (see the project configuration above where that name is used to start the
diff --git a/tools/stress-test/src/main.rs b/tools/stress-test/src/main.rs
index 1e67edc01fc..33890545d9b 100644
--- a/tools/stress-test/src/main.rs
+++ b/tools/stress-test/src/main.rs
@@ -170,7 +170,7 @@ impl State {
         ctx: Arc<Context>,
         cli_state: &CliState,
     ) -> ockam::Result<Arc<InMemoryNode>> {
-        let tcp = TcpTransport::create(&ctx)?;
+        let tcp = TcpTransport::get_or_create(&ctx)?;
         let options = TcpListenerOptions::new();
         let listener = tcp.listen(&"127.0.0.1:0", options).await?;