diff --git a/launchdarkly-server-sdk/examples/print_flags.rs b/launchdarkly-server-sdk/examples/print_flags.rs
index 5a7c3b3..352e80b 100644
--- a/launchdarkly-server-sdk/examples/print_flags.rs
+++ b/launchdarkly-server-sdk/examples/print_flags.rs
@@ -14,7 +14,7 @@ use tokio::time;
 async fn main() {
     env_logger::init_from_env(Env::new().default_filter_or("info"));
 
-    info!("Connecting...");
+    info!(target: "ld-server-sdk::example", "Connecting...");
 
     let flags: Vec<String> = env::args().skip(1).collect();
     let mut bool_flags = Vec::<String>::new();
@@ -27,7 +27,7 @@ async fn main() {
         } else if let ["str", name] = bits {
             str_flags.push(name.to_string());
         } else if let [flag_type, _] = bits {
-            error!("Unsupported flag type {} in {}", flag_type, flag);
+            error!(target: "ld-server-sdk::example", "Unsupported flag type {} in {}", flag_type, flag);
             exit(2);
         } else if let [name] = bits {
             bool_flags.push(name.to_string());
@@ -36,7 +36,7 @@ async fn main() {
         }
     }
     if bool_flags.is_empty() && str_flags.is_empty() {
-        error!("Please list some flags to watch.");
+        error!(target: "ld-server-sdk::example", "Please list some flags to watch.");
         exit(1);
     }
 
@@ -67,6 +67,7 @@ async fn main() {
         (Err(_), Err(_), Err(_)) => {}
         _ => {
             error!(
+                target: "ld-server-sdk::example",
                 "Please specify all URLs LAUNCHDARKLY_STREAM_URL,\
              LAUNCHDARKLY_EVENTS_URL, and LAUNCHDARKLY_POLLING_URL"
             );
@@ -85,7 +86,7 @@ async fn main() {
         .unwrap_or(false); // A timeout (None) can be treated as initialization failure
 
     if !initialized {
-        error!("The client failed to initialize!");
+        error!(target: "ld-server-sdk::example", "The client failed to initialize!");
     }
 
     loop {
@@ -95,6 +96,7 @@ async fn main() {
             for flag_key in &bool_flags {
                 let flag_detail = client.bool_variation_detail(context, flag_key, false);
                 info!(
+                    target: "ld-server-sdk::example",
                     "context {:?}, flag {}: {:?}",
                     context.key(),
                     flag_key,
@@ -105,6 +107,7 @@ async fn main() {
                 let flag_detail =
                     client.str_variation_detail(context, flag_key, "default".to_string());
                 info!(
+                    target: "ld-server-sdk::example",
                     "context {:?}, flag {}: {:?}",
                     context.key(),
                     flag_key,
diff --git a/launchdarkly-server-sdk/examples/progress.rs b/launchdarkly-server-sdk/examples/progress.rs
index 5de00ec..e3d39e5 100644
--- a/launchdarkly-server-sdk/examples/progress.rs
+++ b/launchdarkly-server-sdk/examples/progress.rs
@@ -64,6 +64,7 @@ fn main() {
         (Err(_), Err(_), Err(_)) => {}
         _ => {
             error!(
+                    target: "ld-server-sdk::example",
                 "Please specify all URLs LAUNCHDARKLY_STREAM_URL,\
              LAUNCHDARKLY_EVENTS_URL, and LAUNCHDARKLY_POLLING_URL"
             );
diff --git a/launchdarkly-server-sdk/src/client.rs b/launchdarkly-server-sdk/src/client.rs
index 26a7c5a..e6c6c6d 100644
--- a/launchdarkly-server-sdk/src/client.rs
+++ b/launchdarkly-server-sdk/src/client.rs
@@ -164,7 +164,7 @@ impl Client {
     /// Create a new instance of a [Client] based on the provided [Config] parameter.
     pub fn build(config: Config) -> Result<Self, BuildError> {
         if config.offline() {
-            info!("Started LaunchDarkly Client in offline mode");
+            info!(target: "ld-server-sdk", "Started LaunchDarkly Client in offline mode");
         }
 
         let tags = config.application_tag();
@@ -286,7 +286,7 @@ impl Client {
     /// return a boolean indicating whether or not the SDK has successfully initialized.
     pub async fn wait_for_initialization(&self, timeout: Duration) -> Option<bool> {
         if timeout > Duration::from_secs(60) {
-            warn!("wait_for_initialization was configured to block for up to {} seconds. We recommend blocking no longer than 60 seconds.", timeout.as_secs());
+            warn!(target: "ld-server-sdk", "wait_for_initialization was configured to block for up to {} seconds. We recommend blocking no longer than 60 seconds.", timeout.as_secs());
         }
 
         let initialized = tokio::time::timeout(timeout, self.initialized_async_internal()).await;
@@ -329,7 +329,7 @@ impl Client {
         // channel, so sending on it would always result in an error.
         if !self.offline {
             if let Err(e) = self.shutdown_broadcast.send(()) {
-                error!("Failed to shutdown client appropriately: {}", e);
+                error!(target: "ld-server-sdk", "Failed to shutdown client appropriately: {}", e);
             }
         }
 
@@ -374,6 +374,7 @@ impl Client {
             b
         } else {
             warn!(
+                target: "ld-server-sdk",
                 "bool_variation called for a non-bool flag {:?} (got {:?})",
                 flag_key, val
             );
@@ -394,6 +395,7 @@ impl Client {
             s
         } else {
             warn!(
+                target: "ld-server-sdk",
                 "str_variation called for a non-string flag {:?} (got {:?})",
                 flag_key, val
             );
@@ -414,6 +416,7 @@ impl Client {
             f
         } else {
             warn!(
+                target: "ld-server-sdk",
                 "float_variation called for a non-float flag {:?} (got {:?})",
                 flag_key, val
             );
@@ -434,6 +437,7 @@ impl Client {
             f
         } else {
             warn!(
+                target: "ld-server-sdk",
                 "int_variation called for a non-int flag {:?} (got {:?})",
                 flag_key, val
             );
@@ -578,13 +582,14 @@ impl Client {
     ) -> FlagDetail {
         if self.offline {
             warn!(
+                target: "ld-server-sdk",
                 "all_flags_detail() called, but client is in offline mode. Returning empty state"
             );
             return FlagDetail::new(false);
         }
 
         if !self.initialized() {
-            warn!("all_flags_detail() called before client has finished initializing! Feature store unavailable - returning empty state");
+            warn!(target: "ld-server-sdk", "all_flags_detail() called before client has finished initializing! Feature store unavailable - returning empty state");
             return FlagDetail::new(false);
         }
 
@@ -755,12 +760,14 @@ impl Client {
                         );
                     }
                     Err(e) => error!(
-                        "Failed to build migration event, no event will be sent: {}",
-                        e
-                    ),
+                    target: "ld-server-sdk",
+                            "Failed to build migration event, no event will be sent: {}",
+                            e
+                        ),
                 }
             }
             Err(e) => error!(
+                target: "ld-server-sdk",
                 "Failed to lock migration tracker, no event will be sent: {}",
                 e
             ),
diff --git a/launchdarkly-server-sdk/src/config.rs b/launchdarkly-server-sdk/src/config.rs
index 1fa86ad..5c7f4cf 100644
--- a/launchdarkly-server-sdk/src/config.rs
+++ b/launchdarkly-server-sdk/src/config.rs
@@ -85,7 +85,7 @@ impl ApplicationInfo {
         match tag.is_valid() {
             Ok(_) => self.tags.push(tag),
             Err(e) => {
-                warn!("{}", e)
+                warn!(target: "ld-server-sdk", "{}", e)
             }
         }
 
@@ -269,30 +269,31 @@ impl ConfigBuilder {
             Some(_data_store_builder) => self.data_store_builder.unwrap(),
         };
 
-        let data_source_builder_result: Result<Box<dyn DataSourceFactory>, BuildError> =
-            match self.data_source_builder {
-                None if self.offline => Ok(Box::new(NullDataSourceBuilder::new())),
-                Some(_) if self.offline => {
-                    warn!("Custom data source builders will be ignored when in offline mode");
-                    Ok(Box::new(NullDataSourceBuilder::new()))
-                }
-                Some(builder) => Ok(builder),
-                #[cfg(feature = "rustls")]
-                None => Ok(Box::new(StreamingDataSourceBuilder::<
-                    hyper_rustls::HttpsConnector<hyper::client::HttpConnector>,
-                >::new())),
-                #[cfg(not(feature = "rustls"))]
-                None => Err(BuildError::InvalidConfig(
-                    "data source builder required when rustls is disabled".into(),
-                )),
-            };
+        let data_source_builder_result: Result<Box<dyn DataSourceFactory>, BuildError> = match self
+            .data_source_builder
+        {
+            None if self.offline => Ok(Box::new(NullDataSourceBuilder::new())),
+            Some(_) if self.offline => {
+                warn!(target: "ld-server-sdk", "Custom data source builders will be ignored when in offline mode");
+                Ok(Box::new(NullDataSourceBuilder::new()))
+            }
+            Some(builder) => Ok(builder),
+            #[cfg(feature = "rustls")]
+            None => Ok(Box::new(StreamingDataSourceBuilder::<
+                hyper_rustls::HttpsConnector<hyper::client::HttpConnector>,
+            >::new())),
+            #[cfg(not(feature = "rustls"))]
+            None => Err(BuildError::InvalidConfig(
+                "data source builder required when rustls is disabled".into(),
+            )),
+        };
         let data_source_builder = data_source_builder_result?;
 
         let event_processor_builder_result: Result<Box<dyn EventProcessorFactory>, BuildError> =
             match self.event_processor_builder {
                 None if self.offline => Ok(Box::new(NullEventProcessorBuilder::new())),
                 Some(_) if self.offline => {
-                    warn!("Custom event processor builders will be ignored when in offline mode");
+                    warn!(target: "ld-server-sdk", "Custom event processor builders will be ignored when in offline mode");
                     Ok(Box::new(NullEventProcessorBuilder::new()))
                 }
                 Some(builder) => Ok(builder),
diff --git a/launchdarkly-server-sdk/src/data_source.rs b/launchdarkly-server-sdk/src/data_source.rs
index 55c786f..95bc235 100644
--- a/launchdarkly-server-sdk/src/data_source.rs
+++ b/launchdarkly-server-sdk/src/data_source.rs
@@ -132,11 +132,11 @@ impl DataSource for StreamingDataSource {
                         let event = match event {
                             Some(Ok(event)) => match event {
                                 es::SSE::Connected(_) => {
-                                    debug!("data source connected");
+                                    debug!(target: "ld-server-sdk", "data source connected");
                                     continue;
                                 },
                                 es::SSE::Comment(str)=> {
-                                    debug!("data source got a comment: {}", str);
+                                    debug!(target: "ld-server-sdk", "data source got a comment: {}", str);
                                     continue;
                                 },
                                 es::SSE::Event(ev) => ev,
@@ -146,7 +146,7 @@ impl DataSource for StreamingDataSource {
                                     true => continue,
                                     _ => {
                                         notify_init.call_once(|| (init_complete)(false));
-                                        warn!("Returned unrecoverable failure. Unexpected response {}", response.status());
+                                        warn!(target: "ld-server-sdk", "Returned unrecoverable failure. Unexpected response {}", response.status());
                                         break
                                     }
                                 }
@@ -157,13 +157,13 @@ impl DataSource for StreamingDataSource {
                                         continue;
                                     }
                                     _ => {
-                                        error!("unhandled error on event stream: {:?}", e);
+                                        error!(target: "ld-server-sdk", "unhandled error on event stream: {:?}", e);
                                         break;
                                     }
                                 }
                             },
                             None => {
-                                error!("unexpected end of event stream");
+                                error!(target: "ld-server-sdk", "unexpected end of event stream");
                                 break;
                             }
                         };
@@ -171,7 +171,7 @@ impl DataSource for StreamingDataSource {
                         let data_store = data_store.clone();
                         let mut data_store = data_store.write();
 
-                        debug!("data source got an event: {}", event.event_type);
+                        debug!(target: "ld-server-sdk", "data source got an event: {}", event.event_type);
 
                         let stored = match event.event_type.as_str() {
                             "put" => process_put(&mut *data_store, event),
@@ -181,7 +181,7 @@ impl DataSource for StreamingDataSource {
                         };
                         if let Err(e) = stored {
                             init_success = false;
-                            error!("error processing update: {:?}", e);
+                            error!(target: "ld-server-sdk", "error processing update: {:?}", e);
                         }
 
                         notify_init.call_once(|| (init_complete)(init_success));
@@ -223,12 +223,12 @@ impl DataSource for PollingDataSource {
             Ok(factory) => match factory.build(self.tags.clone()) {
                 Ok(requester) => requester,
                 Err(e) => {
-                    error!("{:?}", e);
+                    error!(target: "ld-server-sdk", "{:?}", e);
                     return;
                 }
             },
             Err(e) => {
-                error!("{:?}", e);
+                error!(target: "ld-server-sdk", "{:?}", e);
                 return;
             }
         };
@@ -252,10 +252,10 @@ impl DataSource for PollingDataSource {
                                 notify_init.call_once(|| init_complete(true));
                             }
                             Err(FeatureRequesterError::Temporary) => {
-                                warn!("feature requester has returned a temporary failure");
+                                warn!(target: "ld-server-sdk", "feature requester has returned a temporary failure");
                             }
                             Err(FeatureRequesterError::Permanent) => {
-                                error!("feature requester has returned a permanent failure");
+                                error!(target: "ld-server-sdk", "feature requester has returned a permanent failure");
                                 notify_init.call_once(|| init_complete(false));
                                 break;
                             }
diff --git a/launchdarkly-server-sdk/src/events/dispatcher.rs b/launchdarkly-server-sdk/src/events/dispatcher.rs
index 9d3ab3d..eba3763 100644
--- a/launchdarkly-server-sdk/src/events/dispatcher.rs
+++ b/launchdarkly-server-sdk/src/events/dispatcher.rs
@@ -35,7 +35,7 @@ impl Outbox {
         if self.events.len() == self.capacity {
             if !self.capacity_exceeded {
                 self.capacity_exceeded = true;
-                warn!("Exceeded event queue capacity. Increase capacity to avoid dropping events.");
+                warn!(target: "ld-server-sdk", "Exceeded event queue capacity. Increase capacity to avoid dropping events.");
             }
             return;
         }
@@ -108,7 +108,7 @@ impl EventDispatcher {
         let rt = match rt {
             Ok(rt) => rt,
             Err(e) => {
-                error!("Could not start runtime for event sending: {}", e);
+                error!(target: "ld-server-sdk", "Could not start runtime for event sending: {}", e);
                 return;
             }
         };
@@ -116,7 +116,7 @@ impl EventDispatcher {
         let (send, recv) = bounded::<()>(1);
 
         loop {
-            debug!("waiting for a batch to send");
+            debug!(target: "ld-server-sdk", "waiting for a batch to send");
 
             loop {
                 select! {
@@ -128,7 +128,7 @@ impl EventDispatcher {
                         },
                         Ok(_) => continue,
                         Err(e) => {
-                            error!("event_result_rx is disconnected. Shutting down dispatcher: {}", e);
+                            error!(target: "ld-server-sdk", "event_result_rx is disconnected. Shutting down dispatcher: {}", e);
                             return;
                         }
                     },
@@ -158,7 +158,7 @@ impl EventDispatcher {
                             return;
                         }
                         Err(e) => {
-                            error!("inbox_rx is disconnected. Shutting down dispatcher: {}", e);
+                            error!(target: "ld-server-sdk", "inbox_rx is disconnected. Shutting down dispatcher: {}", e);
                             return;
                         }
                     }
@@ -172,7 +172,7 @@ impl EventDispatcher {
             if !self.outbox.is_empty() {
                 let payload = self.outbox.get_payload();
 
-                debug!("Sending batch of {} events", payload.len());
+                debug!(target: "ld-server-sdk", "Sending batch of {} events", payload.len());
 
                 let sender = self.events_configuration.event_sender.clone();
                 let results = event_result_tx.clone();
@@ -293,11 +293,11 @@ impl EventDispatcher {
         let key = context.canonical_key();
 
         if self.context_keys.get(key).is_none() {
-            trace!("noticing new context {:?}", key);
+            trace!(target: "ld-server-sdk", "noticing new context {:?}", key);
             self.context_keys.put(key.to_owned(), ());
             true
         } else {
-            trace!("ignoring already-seen context {:?}", key);
+            trace!(target: "ld-server-sdk", "ignoring already-seen context {:?}", key);
             false
         }
     }
diff --git a/launchdarkly-server-sdk/src/events/processor.rs b/launchdarkly-server-sdk/src/events/processor.rs
index 9296602..8216f49 100644
--- a/launchdarkly-server-sdk/src/events/processor.rs
+++ b/launchdarkly-server-sdk/src/events/processor.rs
@@ -78,7 +78,7 @@ impl EventProcessor for EventProcessorImpl {
             .is_err()
         {
             self.inbox_full_once.call_once(|| {
-                warn!("Events are being produced faster than they can be processed; some events will be dropped")
+                warn!(target: "ld-server-sdk", "Events are being produced faster than they can be processed; some events will be dropped")
             });
         }
     }
@@ -91,7 +91,7 @@ impl EventProcessor for EventProcessorImpl {
         let (sender, receiver) = bounded::<()>(1);
 
         if self.inbox_tx.send(EventDispatcherMessage::Flush).is_err() {
-            error!("Failed to send final flush message. Cannot stop event processor");
+            error!(target: "ld-server-sdk", "Failed to send final flush message. Cannot stop event processor");
             return;
         }
 
@@ -100,7 +100,7 @@ impl EventProcessor for EventProcessorImpl {
             .send(EventDispatcherMessage::Close(sender))
             .is_err()
         {
-            error!("Failed to send close message. Cannot stop event processor");
+            error!(target: "ld-server-sdk", "Failed to send close message. Cannot stop event processor");
             return;
         }
 
diff --git a/launchdarkly-server-sdk/src/events/sender.rs b/launchdarkly-server-sdk/src/events/sender.rs
index f8b6a54..9699d40 100644
--- a/launchdarkly-server-sdk/src/events/sender.rs
+++ b/launchdarkly-server-sdk/src/events/sender.rs
@@ -104,6 +104,7 @@ where
             let uuid = Uuid::new_v4();
 
             debug!(
+                target: "ld-server-sdk",
                 "Sending ({}): {}",
                 uuid,
                 serde_json::to_string_pretty(&events).unwrap_or_else(|e| e.to_string())
@@ -115,9 +116,10 @@ where
                 Ok(json) => json,
                 Err(e) => {
                     error!(
-                        "Failed to serialize event payload. Some events were dropped: {:?}",
-                        e
-                    );
+                    target: "ld-server-sdk",
+                            "Failed to serialize event payload. Some events were dropped: {:?}",
+                            e
+                        );
                     return;
                 }
             };
@@ -168,7 +170,7 @@ where
                     Err(e) => {
                         // It appears this type of error will not be an HTTP error.
                         // It will be a closed connection, aborted write, timeout, etc.
-                        error!("Failed to send events. Some events were dropped: {:?}", e);
+                        error!(target: "ld-server-sdk", "Failed to send events. Some events were dropped: {:?}", e);
                         result_tx
                             .send(EventSenderResult {
                                 success: false,
diff --git a/launchdarkly-server-sdk/src/feature_requester.rs b/launchdarkly-server-sdk/src/feature_requester.rs
index e435036..6c9b4c6 100644
--- a/launchdarkly-server-sdk/src/feature_requester.rs
+++ b/launchdarkly-server-sdk/src/feature_requester.rs
@@ -82,7 +82,7 @@ where
                 Err(e) => {
                     // It appears this type of error will not be an HTTP error.
                     // It will be a closed connection, aborted write, timeout, etc.
-                    error!("An error occurred while retrieving flag information {}", e,);
+                    error!(target: "ld-server-sdk", "An error occurred while retrieving flag information {}", e,);
                     return Err(FeatureRequesterError::Temporary);
                 }
             };
@@ -105,9 +105,10 @@ where
                     .await
                     .map_err(|e| {
                         error!(
-                            "An error occurred while reading the polling response body: {}",
-                            e
-                        );
+                        target: "ld-server-sdk",
+                                    "An error occurred while reading the polling response body: {}",
+                                    e
+                                );
                         FeatureRequesterError::Temporary
                     })?;
                 let json = serde_json::from_slice::<AllData<Flag, Segment>>(bytes.as_ref());
@@ -115,19 +116,20 @@ where
                 return match json {
                     Ok(all_data) => {
                         if !etag.is_empty() {
-                            debug!("Caching data for future use with etag: {}", etag);
+                            debug!(target: "ld-server-sdk", "Caching data for future use with etag: {}", etag);
                             self.cache = Some(CachedEntry(all_data.clone(), etag));
                         }
                         Ok(all_data)
                     }
                     Err(e) => {
-                        error!("An error occurred while parsing the json response: {}", e);
+                        error!(target: "ld-server-sdk", "An error occurred while parsing the json response: {}", e);
                         Err(FeatureRequesterError::Temporary)
                     }
                 };
             }
 
             error!(
+                target: "ld-server-sdk",
                 "An error occurred while retrieving flag information. (status: {})",
                 response.status().as_str()
             );
diff --git a/launchdarkly-server-sdk/src/migrations/migrator.rs b/launchdarkly-server-sdk/src/migrations/migrator.rs
index 4e00268..1f17b1e 100644
--- a/launchdarkly-server-sdk/src/migrations/migrator.rs
+++ b/launchdarkly-server-sdk/src/migrations/migrator.rs
@@ -238,7 +238,7 @@ where
         if let Ok(mut tracker) = tracker.lock() {
             tracker.operation(Operation::Read);
         } else {
-            error!("Failed to acquire tracker lock. Cannot track migration write.");
+            error!(target: "ld-server-sdk", "Failed to acquire tracker lock. Cannot track migration write.");
         }
 
         let mut old = Executor {
@@ -307,7 +307,7 @@ where
         if let Ok(mut tracker) = tracker.lock() {
             tracker.operation(Operation::Write);
         } else {
-            error!("Failed to acquire tracker lock. Cannot track migration write.");
+            error!(target: "ld-server-sdk", "Failed to acquire tracker lock. Cannot track migration write.");
         }
 
         let mut old = Executor {
@@ -403,7 +403,7 @@ where
             if let Ok(mut tracker) = tracker.lock() {
                 tracker.consistent(|| compare(authoritative, nonauthoritative));
             } else {
-                error!("Failed to acquire tracker lock. Cannot track consistency.");
+                error!(target: "ld-server-sdk", "Failed to acquire tracker lock. Cannot track consistency.");
             }
         }
     }
diff --git a/launchdarkly-server-sdk/src/reqwest.rs b/launchdarkly-server-sdk/src/reqwest.rs
index 9fcc2b9..ef37d52 100644
--- a/launchdarkly-server-sdk/src/reqwest.rs
+++ b/launchdarkly-server-sdk/src/reqwest.rs
@@ -12,7 +12,7 @@ pub fn is_http_error_recoverable(status: u16) -> bool {
         );
     }
 
-    warn!("Unable to determine if status code is recoverable");
+    warn!(target: "ld-server-sdk", "Unable to determine if status code is recoverable");
     false
 }
 
diff --git a/launchdarkly-server-sdk/src/stores/persistent_store_wrapper.rs b/launchdarkly-server-sdk/src/stores/persistent_store_wrapper.rs
index a2831e6..cc051cb 100644
--- a/launchdarkly-server-sdk/src/stores/persistent_store_wrapper.rs
+++ b/launchdarkly-server-sdk/src/stores/persistent_store_wrapper.rs
@@ -125,7 +125,7 @@ impl PersistentDataStoreWrapper {
     fn cache_items(&self, all_data: AllData<StorageItem<Flag>, StorageItem<Segment>>) {
         self.cache_flags(all_data.flags);
         self.cache_segments(all_data.segments);
-        debug!("flag and segment caches have been updated");
+        debug!(target: "ld-server-sdk", "flag and segment caches have been updated");
     }
 }
 
@@ -145,14 +145,14 @@ impl Store for PersistentDataStoreWrapper {
                         item.into()
                     }
                     Err(e) => {
-                        warn!("failed to convert serialized item into flag: {}", e);
+                        warn!(target: "ld-server-sdk", "failed to convert serialized item into flag: {}", e);
                         None
                     }
                 }
             }
             Ok(None) => None,
             Err(e) => {
-                warn!("persistent store failed to retrieve flag: {}", e);
+                warn!(target: "ld-server-sdk", "persistent store failed to retrieve flag: {}", e);
                 None
             }
         }
@@ -173,14 +173,14 @@ impl Store for PersistentDataStoreWrapper {
                         item.into()
                     }
                     Err(e) => {
-                        warn!("failed to convert serialized item into segment: {}", e);
+                        warn!(target: "ld-server-sdk", "failed to convert serialized item into segment: {}", e);
                         None
                     }
                 }
             }
             Ok(None) => None,
             Err(e) => {
-                warn!("persistent store failed to retrieve segment: {}", e);
+                warn!(target: "ld-server-sdk", "persistent store failed to retrieve segment: {}", e);
                 None
             }
         }
@@ -196,6 +196,7 @@ impl DataStore for PersistentDataStoreWrapper {
 
         match serialized_data {
             Err(e) => warn!(
+                target: "ld-server-sdk",
                 "failed to deserialize payload; cannot initialize store {}",
                 e
             ),
@@ -204,13 +205,13 @@ impl DataStore for PersistentDataStoreWrapper {
 
                 match result {
                     Ok(()) => {
-                        debug!("data store has been updated with new flag data");
+                        debug!(target: "ld-server-sdk", "data store has been updated with new flag data");
                         self.cache_items(all_data.into());
                     }
                     Err(e) => {
-                        error!("failed to init store: {}", e);
+                        error!(target: "ld-server-sdk", "failed to init store: {}", e);
                         if self.flags.cache_is_infinite() {
-                            debug!("updating non-expiring cache");
+                            debug!(target: "ld-server-sdk", "updating non-expiring cache");
                             self.cache_items(all_data.into())
                         }
                     }
@@ -249,13 +250,13 @@ impl DataStore for PersistentDataStoreWrapper {
                         HashMap::from_iter(flag_iter)
                     }
                     Err(e) => {
-                        warn!("failed to convert serialized items into flags: {}", e);
+                        warn!(target: "ld-server-sdk", "failed to convert serialized items into flags: {}", e);
                         HashMap::new()
                     }
                 }
             }
             Err(e) => {
-                warn!("persistent store failed to retrieve all flags: {}", e);
+                warn!(target: "ld-server-sdk", "persistent store failed to retrieve all flags: {}", e);
                 HashMap::new()
             }
         }
diff --git a/launchdarkly-server-sdk/src/stores/store.rs b/launchdarkly-server-sdk/src/stores/store.rs
index 28d87c2..5b9f5f9 100644
--- a/launchdarkly-server-sdk/src/stores/store.rs
+++ b/launchdarkly-server-sdk/src/stores/store.rs
@@ -80,7 +80,7 @@ impl Store for InMemoryDataStore {
 impl DataStore for InMemoryDataStore {
     fn init(&mut self, new_data: AllData<Flag, Segment>) {
         self.data = new_data.into();
-        debug!("data store has been updated with new flag data");
+        debug!(target: "ldsdk", "data store has been updated with new flag data");
     }
 
     fn all_flags(&self) -> HashMap<String, Flag> {