No session ids

Signed-off-by: Bob Weinand <bob.weinand@datadoghq.com>

Author: bwoebi

datadog-ipc/src/platform/unix/sockets/linux.rs

@@ -25,19 +25,20 @@ impl SeqpacketListener {
     /// Removes any stale socket file before binding (standard Unix practice).
     pub fn bind(path: impl AsRef<Path>) -> io::Result<Self> {
         let _ = std::fs::remove_file(path.as_ref());
-        let fd = create_seqpacket_socket()?;
         let addr = UnixAddr::new(path.as_ref()).map_err(io::Error::from)?;
-        bind(fd.as_raw_fd(), &addr).map_err(io::Error::from)?;
-        listen(&fd, Backlog::new(128).map_err(io::Error::from)?).map_err(io::Error::from)?;
-        Ok(Self { inner: fd })
+        Self::do_bind(addr)
     }
 
     /// Bind to a Linux abstract socket name and start listening.
     pub fn bind_abstract(name: &[u8]) -> io::Result<Self> {
-        let fd = create_seqpacket_socket()?;
         let addr = UnixAddr::new_abstract(name).map_err(io::Error::from)?;
+        Self::do_bind(addr)
+    }
+    
+    fn do_bind(addr: UnixAddr) -> io::Result<Self> {
+        let fd = create_seqpacket_socket()?;
         bind(fd.as_raw_fd(), &addr).map_err(io::Error::from)?;
-        listen(&fd, Backlog::new(128).map_err(io::Error::from)?).map_err(io::Error::from)?;
+        listen(&fd, Backlog::new(128).unwrap_or(Backlog::MAXCONN)).map_err(io::Error::from)?;
         Ok(Self { inner: fd })
     }
 

datadog-sidecar-ffi/src/lib.rs

@@ -645,12 +645,10 @@ pub unsafe extern "C" fn ddog_sidecar_session_set_config(
 #[allow(clippy::missing_safety_doc)]
 pub unsafe extern "C" fn ddog_sidecar_session_set_process_tags(
     transport: &mut Box<SidecarTransport>,
-    session_id: ffi::CharSlice,
     process_tags: ffi::CharSlice,
 ) -> MaybeError {
     try_c!(blocking::set_session_process_tags(
         transport,
-        session_id.to_utf8_lossy().into(),
         process_tags.to_utf8_lossy().into(),
     ));
 
@@ -1272,12 +1270,10 @@ pub unsafe extern "C" fn ddog_sidecar_dogstatsd_set(
 #[allow(clippy::missing_safety_doc)]
 pub unsafe extern "C" fn ddog_sidecar_set_test_session_token(
     transport: &mut Box<SidecarTransport>,
-    session_id: ffi::CharSlice,
     token: ffi::CharSlice,
 ) -> MaybeError {
     try_c!(blocking::set_test_session_token(
         transport,
-        session_id.to_utf8_lossy().into_owned(),
         token.to_utf8_lossy().into_owned(),
     ));
 

datadog-sidecar/src/service/blocking.rs

@@ -173,8 +173,8 @@ pub fn shutdown_runtime(
 }
 
 /// Shuts down a session.
-pub fn shutdown_session(transport: &mut SidecarTransport, session_id: String) -> io::Result<()> {
-    lock_sender(transport)?.shutdown_session(session_id);
+pub fn shutdown_session(transport: &mut SidecarTransport) -> io::Result<()> {
+    lock_sender(transport)?.shutdown_session();
     Ok(())
 }
 
@@ -236,10 +236,9 @@ pub fn set_session_config(
 /// Updates the process tags for an existing session.
 pub fn set_session_process_tags(
     transport: &mut SidecarTransport,
-    session_id: String,
     process_tags: String,
 ) -> io::Result<()> {
-    lock_sender(transport)?.set_session_process_tags(session_id, process_tags);
+    lock_sender(transport)?.set_session_process_tags(process_tags);
     Ok(())
 }
 
@@ -401,10 +400,9 @@ pub fn send_dogstatsd_actions(
 /// Sets x-datadog-test-session-token on all requests for the given session.
 pub fn set_test_session_token(
     transport: &mut SidecarTransport,
-    session_id: String,
     token: String,
 ) -> io::Result<()> {
-    lock_sender(transport)?.set_test_session_token(session_id, token);
+    lock_sender(transport)?.set_test_session_token(token);
     Ok(())
 }
 

datadog-sidecar/src/service/sender.rs

@@ -69,17 +69,6 @@ fn cancel_if_instance(slot: &mut Option<SidecarInterfaceRequest>, instance_id: &
     }
 }
 
-fn cancel_if_session(slot: &mut Option<SidecarInterfaceRequest>, session_id: &str) {
-    let should_cancel = match slot {
-        Some(SidecarInterfaceRequest::SetSessionConfig { session_id: id, .. }) => {
-            id.as_str() == session_id
-        }
-        _ => false,
-    };
-    if should_cancel {
-        *slot = None;
-    }
-}
 
 fn cancel_if_queue(
     slot: &mut Option<SidecarInterfaceRequest>,
@@ -109,8 +98,8 @@ fn coalesce(outbox: &mut SidecarOutbox, incoming: SidecarInterfaceRequest) {
         cancel_if_instance(&mut outbox.set_request_config, instance_id);
         cancel_if_instance(&mut outbox.set_universal_service_tags, instance_id);
     }
-    if let SidecarInterfaceRequest::ShutdownSession { ref session_id } = incoming {
-        cancel_if_session(&mut outbox.set_session_config, session_id);
+    if matches!(incoming, SidecarInterfaceRequest::ShutdownSession {}) {
+        outbox.set_session_config = None;
     }
     if let SidecarInterfaceRequest::ClearQueueId {
         ref instance_id,
@@ -231,13 +220,10 @@ impl SidecarSender {
         self.try_drain_outbox();
     }
 
-    pub fn set_session_process_tags(&mut self, session_id: String, process_tags: String) {
+    pub fn set_session_process_tags(&mut self, process_tags: String) {
         coalesce(
             &mut self.outbox,
-            SidecarInterfaceRequest::SetSessionProcessTags {
-                session_id,
-                process_tags,
-            },
+            SidecarInterfaceRequest::SetSessionProcessTags { process_tags },
         );
         self.try_drain_outbox();
     }
@@ -318,10 +304,10 @@ impl SidecarSender {
         self.try_drain_outbox();
     }
 
-    pub fn shutdown_session(&mut self, session_id: String) {
+    pub fn shutdown_session(&mut self) {
         coalesce(
             &mut self.outbox,
-            SidecarInterfaceRequest::ShutdownSession { session_id },
+            SidecarInterfaceRequest::ShutdownSession {},
         );
         self.try_drain_outbox();
     }
@@ -428,12 +414,11 @@ impl SidecarSender {
             .try_send_send_dogstatsd_actions(instance_id, actions);
     }
 
-    pub fn set_test_session_token(&mut self, session_id: String, token: String) {
+    pub fn set_test_session_token(&mut self, token: String) {
         if !self.try_drain_outbox() {
             return;
         }
-        self.channel
-            .try_send_set_test_session_token(session_id, token);
+        self.channel.try_send_set_test_session_token(token);
     }
 
     pub fn set_read_timeout(&mut self, d: Option<Duration>) -> io::Result<()> {

datadog-sidecar/src/service/sidecar_interface.rs

@@ -61,7 +61,7 @@ pub trait SidecarInterface {
     ///
     /// * `session_id` - The ID of the session.
     /// * `process_tags` - The process tags string.
-    async fn set_session_process_tags(session_id: String, process_tags: String);
+    async fn set_session_process_tags(process_tags: String);
 
     /// Removes the application entry for the given queue ID from the instance.
     ///
@@ -95,7 +95,7 @@ pub trait SidecarInterface {
     /// # Arguments
     ///
     /// * `session_id` - The ID of the session.
-    async fn shutdown_session(session_id: String);
+    async fn shutdown_session();
 
     /// Sends a trace via shared memory.
     ///
@@ -214,7 +214,7 @@ pub trait SidecarInterface {
     ///
     /// * `session_id` - The ID of the session.
     /// * `token` - The session token.
-    async fn set_test_session_token(session_id: String, token: String);
+    async fn set_test_session_token(token: String);
 
     /// Sends a ping to the service.
     #[blocking]