Fix user-after-move in TrackInternal.

Author: kinyoklion

libs/server-sdk/src/client_impl.cpp

@@ -239,17 +239,27 @@ void ClientImpl::TrackInternal(Context const& ctx,
                                std::optional<Value> data,
                                std::optional<double> metric_value,
                                hooks::HookContext const& hook_context) {
-    events_default_.Send([&](EventFactory const& factory) {
-        return factory.Custom(ctx, std::move(event_name), std::move(data),
-                              metric_value);
-    });
 
-    // Execute afterTrack hooks
+    if (!ctx.Valid()) {
+        LD_LOG(logger_, LogLevel::kWarn) << "Track method called with an invalid context";
+        return;
+    }
+    // Execute afterTrack hooks before moving the data
+    // Typically we would execute this after the data has been enqueued.
+    // In this SDK doing so would introduce a performance penalty because we
+    // would need to copy the event_name and data.
+    // In this SDK the data is type-safe, and will be enqueued, so it makes
+    // minimal functional difference.
     if (!config_.Hooks().empty()) {
         hooks::TrackSeriesContext series_context(ctx, event_name, metric_value,
                                                 data, hook_context, std::nullopt);
         hooks::ExecuteAfterTrack(config_.Hooks(), series_context, logger_);
     }
+
+    events_default_.Send([&](EventFactory const& factory) {
+        return factory.Custom(ctx, std::move(event_name), std::move(data),
+                              metric_value);
+    });
 }
 
 void ClientImpl::Track(Context const& ctx,

libs/server-sdk/tests/hooks_test.cpp

@@ -31,6 +31,7 @@ class RecordingHook : public Hook {
     struct TrackCall {
         std::string key;
         std::optional<double> metric_value;
+        std::optional<Value> data;
     };
 
     explicit RecordingHook(std::string name) : metadata_(std::move(name)) {}
@@ -77,6 +78,7 @@ class RecordingHook : public Hook {
         TrackCall call;
         call.key = std::string(series_context.Key());
         call.metric_value = series_context.MetricValue();
+        call.data = series_context.Data();
         track_calls_.push_back(call);
     }
 
@@ -443,6 +445,46 @@ TEST_F(HooksTest, AfterTrackWithMetricValue) {
     EXPECT_EQ(*calls[0].metric_value, 42.5);
 }
 
+// Test that data is properly passed to afterTrack hooks
+// This test would catch use-after-move bugs with ASAN
+TEST_F(HooksTest, AfterTrackReceivesData) {
+    auto hook = std::make_shared<RecordingHook>("TestHook");
+
+    auto config = ConfigBuilder("sdk-key")
+                      .Offline(true)
+                      .Hooks(hook)
+                      .Build()
+                      .value();
+
+    Client client(std::move(config));
+
+    // Test with string data
+    client.Track(context_, "test-event", Value("test-data"));
+
+    auto const& calls = hook->GetTrackCalls();
+    ASSERT_EQ(calls.size(), 1);
+    EXPECT_EQ(calls[0].key, "test-event");
+    ASSERT_TRUE(calls[0].data.has_value());
+    EXPECT_EQ(calls[0].data->AsString(), "test-data");
+
+    hook->Reset();
+
+    // Test with complex data
+    auto complex_data = Value::Object({{"field1", Value("value1")}, {"field2", Value(42)}});
+    client.Track(context_, "test-event-2", complex_data, 99.5);
+
+    auto const& calls2 = hook->GetTrackCalls();
+    ASSERT_EQ(calls2.size(), 1);
+    EXPECT_EQ(calls2[0].key, "test-event-2");
+    ASSERT_TRUE(calls2[0].data.has_value());
+    EXPECT_EQ(calls2[0].data->Type(), Value::Type::kObject);
+    auto const& obj = calls2[0].data->AsObject();
+    EXPECT_EQ(obj["field1"].AsString(), "value1");
+    EXPECT_EQ(obj["field2"].AsInt(), 42);
+    ASSERT_TRUE(calls2[0].metric_value.has_value());
+    EXPECT_EQ(*calls2[0].metric_value, 99.5);
+}
+
 // Requirement 1.3.4: afterTrack handlers execute in order of registration
 TEST_F(HooksTest, AfterTrackExecutesInOrder) {
     auto execution_order = std::make_shared<std::vector<std::string>>();