diff --git a/.gitignore b/.gitignore
index 93c1c62..51298a8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,3 +20,7 @@ compile_commands.json
 CTestTestfile.cmake
 _deps
 cmake-build-debug/
+
+.DS_Store
+test_results_*.log
+*.db
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6c1bf66..e59e97c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,6 @@
+## XX.XX.XX
+- ! Minor breaking change ! SDK Behavior Settings is now enabled by default. Changes made on SDK Manager > SDK Behavior Settings on your server will affect SDK behavior directly.
+
 ## 23.2.4
 - Mitigated an issue where cached events were not queued when a user property was recorded.
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1d72104..44eb368 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,7 +48,8 @@ add_library(countly
   ${CMAKE_CURRENT_SOURCE_DIR}/src/request_builder.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/storage_module_db.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/storage_module_memory.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/src/event.cpp)
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/event.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/configuration_module.cpp)
 
 target_include_directories(countly
   PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
diff --git a/include/countly.hpp b/include/countly.hpp
index 6065b9d..2bf2ced 100644
--- a/include/countly.hpp
+++ b/include/countly.hpp
@@ -24,6 +24,8 @@
 #include "countly/logger_module.hpp"
 #include "countly/storage_module_base.hpp"
 #include "countly/views_module.hpp"
+#include <countly/configuration_module.hpp>
+#include <countly/configuration_provider.hpp>
 #include <countly/crash_module.hpp>
 #include <countly/request_builder.hpp>
 #include <countly/request_module.hpp>
@@ -257,6 +259,8 @@ class Countly : public cly::CountlyDelegates {
     addEvent(event);
   }
 
+  void RecordLocation(const std::string &countryCode, const std::string &city, const std::string &gpsCoordinates, const std::string &ipAddress) override { setLocation(countryCode, city, gpsCoordinates, ipAddress); };
+
   /* Provide 'updateInterval' in seconds. */
   inline void setAutomaticSessionUpdateInterval(unsigned short updateInterval) {
     if (is_sdk_initialized) {
@@ -267,6 +271,35 @@ class Countly : public cly::CountlyDelegates {
     configuration->sessionDuration = updateInterval;
   }
 
+  /**
+   * Disable SDK behavior settings updates that SDK performs periodically from the server.
+   */
+  void disableSDKBehaviorSettingsUpdates() {
+    if (is_sdk_initialized) {
+      log(LogLevel::WARNING, "[Countly] disableSDKBehaviorSettingsUpdates, You can not disable SDK behavior settings updates after SDK initialization.");
+      return;
+    }
+
+    configuration->sdkBehaviorSettingsUpdatesDisabled = true;
+  }
+
+  /**
+   * Provide SDK behavior settings in JSON format string.
+   */
+  void setSDKBehaviorSettings(std::string &settings_json) {
+    if (is_sdk_initialized) {
+      log(LogLevel::WARNING, "[Countly] setSDKBehaviorSettings, You can not provide SDK behavior settings after SDK initialization.");
+      return;
+    }
+
+    if(settings_json.empty()) {
+      log(LogLevel::WARNING, "[Countly] setSDKBehaviorSettings, Provided SDK behavior settings is empty.");
+      return;
+    }
+
+    configuration->sdkBehaviorSettings = settings_json;
+  }
+
 #ifdef COUNTLY_BUILD_TESTS
   /**
    * Convert event queue into list.
@@ -345,6 +378,7 @@ class Countly : public cly::CountlyDelegates {
   std::shared_ptr<cly::RequestBuilder> requestBuilder;
   std::shared_ptr<cly::RequestModule> requestModule;
   std::shared_ptr<cly::StorageModuleBase> storageModule;
+  std::shared_ptr<cly::ConfigurationModule> configurationModule;
   std::shared_ptr<std::mutex> mutex = std::make_shared<std::mutex>();
 
   bool is_queue_being_processed = false;
diff --git a/include/countly/configuration_module.hpp b/include/countly/configuration_module.hpp
new file mode 100644
index 0000000..3334f1b
--- /dev/null
+++ b/include/countly/configuration_module.hpp
@@ -0,0 +1,42 @@
+#ifndef CONFIGURATION_MODULE_HPP_
+#define CONFIGURATION_MODULE_HPP_
+
+#include "countly/configuration_provider.hpp"
+#include "countly/constants.hpp"
+#include "countly/countly_configuration.hpp"
+#include "countly/logger_module.hpp"
+#include "countly/request_builder.hpp"
+#include "countly/request_module.hpp"
+#include "countly/storage_module_base.hpp"
+
+namespace cly {
+class ConfigurationModule : public ConfigurationProvider {
+
+public:
+  ~ConfigurationModule();
+  ConfigurationModule(cly::CountlyDelegates *cly, std::shared_ptr<CountlyConfiguration> config, std::shared_ptr<LoggerModule> logger, std::shared_ptr<RequestBuilder> requestBuilder, std::shared_ptr<StorageModuleBase> storageModule, std::shared_ptr<RequestModule> requestModule,
+                      std::shared_ptr<std::mutex> mutex);
+
+  void fetchConfigFromServer(nlohmann::json session_params);
+  void fetchConfigFromStorage();
+  void startServerConfigUpdateTimer(nlohmann::json session_params);
+  void stopTimer();
+  bool isTrackingEnabled() const override;
+  bool isNetworkingEnabled() const override;
+
+  bool isLocationTrackingEnabled();
+  bool isViewTrackingEnabled() const override;
+  bool isSessionTrackingEnabled();
+  bool isCustomEventTrackingEnabled();
+  bool isCrashReportingEnabled() const override;
+
+  unsigned int getRequestQueueSizeLimit() const override;
+  unsigned int getEventQueueSizeLimit();
+  unsigned int getSessionUpdateInterval();
+
+private:
+  class ConfigurationModuleImpl;
+  std::unique_ptr<ConfigurationModuleImpl> impl;
+};
+} // namespace cly
+#endif
diff --git a/include/countly/configuration_provider.hpp b/include/countly/configuration_provider.hpp
new file mode 100644
index 0000000..e573de0
--- /dev/null
+++ b/include/countly/configuration_provider.hpp
@@ -0,0 +1,16 @@
+#ifndef CONFIGURATION_PROVIDER_HPP_
+#define CONFIGURATION_PROVIDER_HPP_
+namespace cly {
+
+class ConfigurationProvider {
+public:
+    virtual ~ConfigurationProvider() = default;
+
+    virtual bool isNetworkingEnabled() const = 0;
+    virtual bool isTrackingEnabled() const = 0;
+    virtual bool isCrashReportingEnabled() const = 0;
+    virtual bool isViewTrackingEnabled() const = 0;
+    virtual unsigned int getRequestQueueSizeLimit() const = 0;
+};
+} // namespace cly
+#endif
\ No newline at end of file
diff --git a/include/countly/constants.hpp b/include/countly/constants.hpp
index 52b436c..69bbc7c 100644
--- a/include/countly/constants.hpp
+++ b/include/countly/constants.hpp
@@ -93,6 +93,8 @@ class CountlyDelegates {
   virtual void RecordEvent(const std::string &key, const std::map<std::string, std::string> &segmentation, int count, double sum) = 0;
 
   virtual void RecordEvent(const std::string &key, const std::map<std::string, std::string> &segmentation, int count, double sum, double duration) = 0;
+
+  virtual void RecordLocation(const std::string &countryCode, const std::string &city, const std::string &gpsCoordinates, const std::string &ipAddress) = 0;
 };
 
 } // namespace cly
diff --git a/include/countly/countly_configuration.hpp b/include/countly/countly_configuration.hpp
index 6540338..633ee90 100644
--- a/include/countly/countly_configuration.hpp
+++ b/include/countly/countly_configuration.hpp
@@ -76,6 +76,10 @@ struct CountlyConfiguration {
 
   nlohmann::json metrics;
 
+  bool sdkBehaviorSettingsUpdatesDisabled = false;
+
+  std::string sdkBehaviorSettings;
+
   CountlyConfiguration(const std::string appKey, std::string serverUrl) {
     this->appKey = appKey;
     this->serverUrl = serverUrl;
diff --git a/include/countly/crash_module.hpp b/include/countly/crash_module.hpp
index 1cabe7e..e2bbadc 100644
--- a/include/countly/crash_module.hpp
+++ b/include/countly/crash_module.hpp
@@ -35,8 +35,10 @@ class CrashModule {
   void recordException(const std::string &title, const std::string &stackTrace, const bool fatal, const std::map<std::string, std::string> &crashMetrics, const std::map<std::string, std::string> &segmentation = {});
 
 private:
+  friend class Countly;
   class CrashModuleImpl;
   std::unique_ptr<CrashModuleImpl> impl;
+  void setConfigurationProvider(std::weak_ptr<ConfigurationProvider> provider); // try injecting
 };
 } // namespace cly
 #endif
diff --git a/include/countly/request_module.hpp b/include/countly/request_module.hpp
index 7d494a1..3c5087c 100644
--- a/include/countly/request_module.hpp
+++ b/include/countly/request_module.hpp
@@ -9,6 +9,7 @@
 #include "countly/logger_module.hpp"
 #include "countly/request_builder.hpp"
 #include "countly/storage_module_base.hpp"
+#include "countly/configuration_provider.hpp"
 
 namespace cly {
 class RequestModule {
@@ -36,10 +37,12 @@ class RequestModule {
   void clearRequestQueue();
 
   long long RQSize();
+  void setConfigurationProvider(std::weak_ptr<ConfigurationProvider> provider); // try injecting
 
 private:
   class RequestModuleImpl;
   std::unique_ptr<RequestModuleImpl> impl;
+  std::weak_ptr<ConfigurationProvider> _configProvider;
 };
 } // namespace cly
 #endif
diff --git a/include/countly/storage_module_base.hpp b/include/countly/storage_module_base.hpp
index 1cda567..507a35e 100644
--- a/include/countly/storage_module_base.hpp
+++ b/include/countly/storage_module_base.hpp
@@ -94,6 +94,10 @@ class StorageModuleBase {
    * @param request: content of the request
    */
   virtual void RQInsertAtEnd(const std::string &request) = 0;
+
+  virtual void storeSDKBehaviorSettings(const std::string &sdk_behavior_settings) = 0;
+
+  virtual std::string getSDKBehaviorSettings() = 0;
 };
 
 } // namespace cly
diff --git a/include/countly/storage_module_db.hpp b/include/countly/storage_module_db.hpp
index 47bf852..a57022c 100644
--- a/include/countly/storage_module_db.hpp
+++ b/include/countly/storage_module_db.hpp
@@ -24,6 +24,8 @@ class StorageModuleDB : public StorageModuleBase {
   std::vector<std::shared_ptr<DataEntry>> RQPeekAll() override;
   void RQRemoveFront(std::shared_ptr<DataEntry> request) override;
   void RQInsertAtEnd(const std::string &request) override;
+  void storeSDKBehaviorSettings(const std::string &sdk_behavior_settings) override;
+  std::string getSDKBehaviorSettings() override;
 };
 } // namespace cly
 #endif
\ No newline at end of file
diff --git a/include/countly/storage_module_memory.hpp b/include/countly/storage_module_memory.hpp
index f1e3468..89fc3e7 100644
--- a/include/countly/storage_module_memory.hpp
+++ b/include/countly/storage_module_memory.hpp
@@ -26,6 +26,8 @@ class StorageModuleMemory : public StorageModuleBase {
   std::vector<std::shared_ptr<DataEntry>> RQPeekAll() override;
   void RQRemoveFront(std::shared_ptr<DataEntry> request) override;
   void RQInsertAtEnd(const std::string &request) override;
+  void storeSDKBehaviorSettings(const std::string &sdk_behavior_settings) override;
+  std::string getSDKBehaviorSettings() override;
 };
 } // namespace cly
 #endif
\ No newline at end of file
diff --git a/include/countly/views_module.hpp b/include/countly/views_module.hpp
index a7a3d09..1f48006 100644
--- a/include/countly/views_module.hpp
+++ b/include/countly/views_module.hpp
@@ -4,6 +4,7 @@
 #include <memory>
 #include <string>
 
+#include "countly/configuration_provider.hpp"
 #include "countly/constants.hpp"
 #include "countly/logger_module.hpp"
 
@@ -36,10 +37,13 @@ class ViewsModule {
    */
   std::string openView(const std::string &name, const std::map<std::string, std::string> &segmentation = {});
 
+
 private:
+  friend class Countly;
   void _recordView(std::string eventID);
   class ViewModuleImpl;
   std::unique_ptr<ViewModuleImpl> impl;
+  void setConfigurationProvider(std::weak_ptr<ConfigurationProvider> provider); // try injecting
 };
 } // namespace cly
 #endif
diff --git a/src/configuration_module.cpp b/src/configuration_module.cpp
new file mode 100644
index 0000000..077726e
--- /dev/null
+++ b/src/configuration_module.cpp
@@ -0,0 +1,358 @@
+#include "countly/configuration_module.hpp"
+#include <thread>
+
+namespace cly {
+// some keys do not have feature yet, but reserved for future use.
+static constexpr const char *KEY_TIMESTAMP = "t"; // not used yet
+static constexpr const char *KEY_CONFIG = "c";    // used
+static constexpr const char *KEY_VERSION = "v";   // not used yet
+
+static constexpr const char *KEY_TRACKING = "tracking";
+static constexpr const char *KEY_NETWORKING = "networking";
+
+static constexpr const char *KEY_REQ_QUEUE_SIZE = "rqs";
+static constexpr const char *KEY_EVENT_QUEUE_SIZE = "eqs";
+static constexpr const char *KEY_SESSION_UPDATE_INTERVAL = "sui";
+static constexpr const char *KEY_SESSION_TRACKING = "st";
+static constexpr const char *KEY_VIEW_TRACKING = "vt";
+static constexpr const char *KEY_LOCATION_TRACKING = "lt";
+static constexpr const char *KEY_CUSTOM_EVENT_TRACKING = "cet";
+static constexpr const char *KEY_CRASH_REPORTING = "crt";
+static constexpr const char *KEY_SERVER_CONFIG_UPDATE_INTERVAL = "scui";
+static constexpr const char *KEY_LOGGING = "log"; // not used and implemented yet
+
+// whitelist / blacklist - not implemented yet
+static constexpr const char *KEY_EVENT_BLACKLIST = "eb";
+static constexpr const char *KEY_USER_PROPERTY_BLACKLIST = "upb";
+static constexpr const char *KEY_SEGMENTATION_BLACKLIST = "sb";
+static constexpr const char *KEY_EVENT_SEGMENTATION_BLACKLIST = "esb";
+static constexpr const char *KEY_EVENT_WHITELIST = "ew";
+static constexpr const char *KEY_USER_PROPERTY_WHITELIST = "upw";
+static constexpr const char *KEY_SEGMENTATION_WHITELIST = "sw";
+static constexpr const char *KEY_EVENT_SEGMENTATION_WHITELIST = "esw";
+
+// sdk configuration - not implemented yet
+static constexpr const char *KEY_CONSENT_REQUIRED = "cr";
+static constexpr const char *KEY_DROP_OLD_REQUEST_TIME = "dort";
+
+// sdk internal limits - not implemented yet
+static constexpr const char *KEY_LIMIT_KEY_LENGTH = "lkl";
+static constexpr const char *KEY_LIMIT_VALUE_SIZE = "lvs";
+static constexpr const char *KEY_LIMIT_SEG_VALUES = "lsv";
+static constexpr const char *KEY_LIMIT_BREADCRUMB = "lbc";
+static constexpr const char *KEY_LIMIT_TRACE_LINE = "ltlpt";
+static constexpr const char *KEY_LIMIT_TRACE_LENGTH = "ltl";
+// -- This limit is introduced lately and experimental
+static constexpr const char *KEY_USER_PROPERTY_CACHE_LIMIT = "upcl";
+
+// backoff mechanism - not implemented yet
+static constexpr const char *KEY_BACKOFF_MECHANISM = "bom";
+static constexpr const char *KEY_BOM_ACCEPTED_TIMEOUT = "bom_at";
+static constexpr const char *KEY_BOM_RQ_PERCENTAGE = "bom_rqp";
+static constexpr const char *KEY_BOM_REQUEST_AGE = "bom_ra";
+static constexpr const char *KEY_BOM_DURATION = "bom_d";
+
+class ConfigurationModule::ConfigurationModuleImpl {
+private:
+  std::shared_ptr<CountlyConfiguration> _configuration;
+  std::shared_ptr<RequestBuilder> _requestBuilder;
+  std::shared_ptr<StorageModuleBase> _storageModule;
+  std::shared_ptr<RequestModule> _requestModule;
+  cly::CountlyDelegates *_cly;
+  nlohmann::json sdk_behavior_settings;
+
+public:
+  std::shared_ptr<LoggerModule> _logger;
+  std::shared_ptr<std::mutex> _mutex;
+
+  std::atomic<bool> stopConfigThread{false};
+  std::thread configUpdateThread;
+  std::mutex configUpdateMutex;
+  std::condition_variable configUpdateCv;
+
+  // current settings cached for quick access
+  std::atomic<bool> networkingEnabled{true};
+  std::atomic<bool> trackingEnabled{true};
+  std::atomic<bool> sessionTrackingEnabled{true};
+  std::atomic<bool> viewTrackingEnabled{true};
+  std::atomic<bool> locationTrackingEnabled{true};
+  std::atomic<bool> customEventTrackingEnabled{true};
+  std::atomic<bool> crashReportingEnabled{true};
+  std::atomic<unsigned int> eventQueueThreshold{0};
+  std::atomic<unsigned int> requestQueueSizeLimit{0};
+  std::atomic<unsigned int> sessionUpdateInterval{0};
+  std::atomic<unsigned int> serverConfigUpdateInterval{4};
+  ConfigurationModuleImpl(cly::CountlyDelegates *cly, std::shared_ptr<CountlyConfiguration> config, std::shared_ptr<LoggerModule> logger, std::shared_ptr<RequestBuilder> requestBuilder, std::shared_ptr<StorageModuleBase> storageModule, std::shared_ptr<RequestModule> requestModule,
+                          std::shared_ptr<std::mutex> mutex)
+      : _configuration(config), _logger(logger), _requestBuilder(requestBuilder), _storageModule(storageModule), _requestModule(requestModule), _mutex(mutex), _cly(cly) {}
+
+  void _fetchConfigFromServerHTTP(const std::map<std::string, std::string> &data, const nlohmann::json &session_params) {
+    HTTPResponse response = _requestModule->sendHTTP("/o/sdk", _requestBuilder->serializeData(data));
+    if (response.success && response.data.is_object() && response.data.contains(KEY_CONFIG)) {
+      sanitizeConfig(response.data[KEY_CONFIG]);
+      sdk_behavior_settings = response.data[KEY_CONFIG];
+      _storageModule->storeSDKBehaviorSettings(sdk_behavior_settings.dump());
+      _logger->log(LogLevel::INFO, "[ConfigurationModule] _fetchConfigFromServerHTTP, SDK config:\n" + sdk_behavior_settings.dump(2));
+      _onSBSChanged(_populateConfigValues(), session_params);
+    } else {
+      _logger->log(LogLevel::WARNING, cly::utils::format_string("[ConfigurationModule] _fetchConfigFromServerHTTP, failed to fetch response_success: [%s]", response.success ? "true" : "false"));
+    }
+  }
+
+  void _initializeSBSFromStorage() {
+    std::string sbs_string = _storageModule->getSDKBehaviorSettings();
+    if (!sbs_string.empty()) {
+      _processSDKBehaviorSettings(sbs_string);
+      _logger->log(LogLevel::INFO, "[ConfigurationModule] _initializeSBSFromStorage, initialized SDK behavior settings from storage.");
+    } else if (!_configuration->sdkBehaviorSettings.empty()) {
+      _onSBSChanged(_processSDKBehaviorSettings(_configuration->sdkBehaviorSettings));
+      _logger->log(LogLevel::INFO, "[ConfigurationModule] _initializeSBSFromStorage, initialized SDK behavior settings from configuration.");
+    }
+  }
+
+  nlohmann::json _processSDKBehaviorSettings(const std::string &settings) {
+    try {
+      nlohmann::json sbs_json = nlohmann::json::parse(settings);
+      sanitizeConfig(sbs_json);
+      sdk_behavior_settings = sbs_json;
+      _logger->log(LogLevel::INFO, "[ConfigurationModule] _processSDKBehaviorSettings, SDK config:\n" + sdk_behavior_settings.dump(2));
+      return _populateConfigValues();
+    } catch (const nlohmann::json::parse_error &e) {
+      _logger->log(LogLevel::ERROR, "[ConfigurationModule] _processSDKBehaviorSettings, Failed to parse SDK behavior settings: " + std::string(e.what()));
+      return nlohmann::json{};
+    }
+  }
+
+  void _onSBSChanged(const nlohmann::json &changedSettings, const nlohmann::json &session_params = nullptr) {
+    if (_configuration->sdkBehaviorSettingsUpdatesDisabled != true && changedSettings.contains(KEY_SERVER_CONFIG_UPDATE_INTERVAL)) {
+      // restart timer with new interval
+      _stopTimer();
+      _startTimer(session_params);
+    }
+
+    if (changedSettings.contains(KEY_LOCATION_TRACKING) && changedSettings[KEY_LOCATION_TRACKING] == false) {
+      // disable location
+      _cly->RecordLocation("", "", "", "");
+    }
+  }
+
+  nlohmann::json _populateConfigValues() {
+    bool trackingEnabledVal = trackingEnabled.load(std::memory_order_acquire);
+    bool networkingEnabledVal = networkingEnabled.load(std::memory_order_acquire);
+    bool sessionTrackingEnabledVal = sessionTrackingEnabled.load(std::memory_order_acquire);
+    bool viewTrackingEnabledVal = viewTrackingEnabled.load(std::memory_order_acquire);
+    bool locationTrackingEnabledVal = locationTrackingEnabled.load(std::memory_order_acquire);
+    bool customEventTrackingEnabledVal = customEventTrackingEnabled.load(std::memory_order_acquire);
+    bool crashReportingEnabledVal = crashReportingEnabled.load(std::memory_order_acquire);
+    int unsigned serverConfigUpdateIntervalVal = serverConfigUpdateInterval.load(std::memory_order_acquire);
+
+    bool locationTrackingCurrent = getBool(KEY_LOCATION_TRACKING, locationTrackingEnabledVal);
+    int unsigned serverConfigUpdateIntervalCurrent = getUInt(KEY_SERVER_CONFIG_UPDATE_INTERVAL, serverConfigUpdateIntervalVal);
+
+    trackingEnabled.store(getBool(KEY_TRACKING, trackingEnabledVal), std::memory_order_release);
+    networkingEnabled.store(getBool(KEY_NETWORKING, networkingEnabledVal), std::memory_order_release);
+    sessionTrackingEnabled.store(getBool(KEY_SESSION_TRACKING, sessionTrackingEnabledVal), std::memory_order_release);
+    viewTrackingEnabled.store(getBool(KEY_VIEW_TRACKING, viewTrackingEnabledVal), std::memory_order_release);
+    locationTrackingEnabled.store(locationTrackingCurrent, std::memory_order_release);
+    customEventTrackingEnabled.store(getBool(KEY_CUSTOM_EVENT_TRACKING, customEventTrackingEnabledVal), std::memory_order_release);
+    crashReportingEnabled.store(getBool(KEY_CRASH_REPORTING, crashReportingEnabledVal), std::memory_order_release);
+    eventQueueThreshold.store(getUInt(KEY_EVENT_QUEUE_SIZE, _configuration->eventQueueThreshold), std::memory_order_release);
+    requestQueueSizeLimit.store(getUInt(KEY_REQ_QUEUE_SIZE, _configuration->requestQueueThreshold), std::memory_order_release);
+    sessionUpdateInterval.store(getUInt(KEY_SESSION_UPDATE_INTERVAL, _configuration->sessionDuration), std::memory_order_release);
+    serverConfigUpdateInterval.store(getUInt(KEY_SERVER_CONFIG_UPDATE_INTERVAL, 4), std::memory_order_release);
+
+    nlohmann::json changedSettings;
+    if (locationTrackingCurrent != locationTrackingEnabledVal) {
+      changedSettings[KEY_LOCATION_TRACKING] = locationTrackingCurrent;
+    }
+    if (serverConfigUpdateIntervalCurrent != serverConfigUpdateIntervalVal) {
+      changedSettings[KEY_SERVER_CONFIG_UPDATE_INTERVAL] = serverConfigUpdateIntervalCurrent;
+    }
+    return changedSettings;
+  }
+
+  void sanitizeConfig(nlohmann::json &c) {
+    if (!c.is_object()) {
+      c.clear();
+      return;
+    }
+
+    for (auto it = c.begin(); it != c.end();) {
+      std::string key = it.key();
+      auto value = it.value();
+      if (key == KEY_REQ_QUEUE_SIZE || key == KEY_EVENT_QUEUE_SIZE || key == KEY_SESSION_UPDATE_INTERVAL || key == KEY_LIMIT_KEY_LENGTH || key == KEY_LIMIT_VALUE_SIZE || key == KEY_LIMIT_SEG_VALUES || key == KEY_LIMIT_BREADCRUMB || key == KEY_LIMIT_TRACE_LINE || key == KEY_LIMIT_TRACE_LENGTH ||
+          key == KEY_USER_PROPERTY_CACHE_LIMIT || key == KEY_DROP_OLD_REQUEST_TIME || key == KEY_SERVER_CONFIG_UPDATE_INTERVAL) {
+        if (!value.is_number_unsigned()) {
+          it = c.erase(it);
+          continue;
+        }
+      } else if (key == KEY_TRACKING || key == KEY_NETWORKING || key == KEY_LOGGING || key == KEY_SESSION_TRACKING || key == KEY_VIEW_TRACKING || key == KEY_LOCATION_TRACKING || key == KEY_CUSTOM_EVENT_TRACKING || key == KEY_CONSENT_REQUIRED || key == KEY_CRASH_REPORTING) {
+        if (!value.is_boolean()) {
+          it = c.erase(it);
+          continue;
+        }
+      } else if (key == KEY_EVENT_BLACKLIST || key == KEY_USER_PROPERTY_BLACKLIST || key == KEY_SEGMENTATION_BLACKLIST || key == KEY_EVENT_SEGMENTATION_BLACKLIST || key == KEY_EVENT_WHITELIST || key == KEY_USER_PROPERTY_WHITELIST || key == KEY_SEGMENTATION_WHITELIST ||
+                 key == KEY_EVENT_SEGMENTATION_WHITELIST) {
+        if (!value.is_array()) {
+          it = c.erase(it);
+          continue;
+        }
+      } else {
+        _logger->log(LogLevel::DEBUG, "[ConfigurationModule] sanitizeConfig, removing unknown key: " + key);
+        it = c.erase(it);
+        continue;
+      }
+      ++it;
+    }
+  }
+
+  void _updateConfigPeriodically(const nlohmann::json &session_params) {
+    std::unique_lock<std::mutex> lock(configUpdateMutex);
+
+    while (!stopConfigThread.load(std::memory_order_acquire)) {
+
+      unsigned int interval = getUInt(KEY_SERVER_CONFIG_UPDATE_INTERVAL, 4);
+
+      if (interval < 1) {
+        interval = 4;
+      }
+
+      bool stopped = configUpdateCv.wait_for(lock, std::chrono::hours(interval), [&] { return stopConfigThread.load(std::memory_order_acquire); });
+      if (stopped) {
+        return;
+      }
+
+      lock.unlock();
+
+      _mutex->lock();
+      std::map<std::string, std::string> data = {{"method", "sc"}, {"app_key", session_params["app_key"].get<std::string>()}, {"device_id", session_params["device_id"].get<std::string>()}};
+      _mutex->unlock();
+      _fetchConfigFromServerHTTP(data, session_params);
+
+      lock.lock();
+    }
+  }
+
+  void _stopTimer() {
+    if (_configuration->sdkBehaviorSettingsUpdatesDisabled) {
+      _logger->log(LogLevel::INFO, "[ConfigurationModule] _stopTimer, SDK behavior settings updates are disabled.");
+      return;
+    }
+
+    _logger->log(LogLevel::WARNING, "[ConfigurationModule] stopTimer, stopping server config update timer thread.");
+    stopConfigThread.store(true, std::memory_order_release);
+    configUpdateCv.notify_all();
+
+    if (configUpdateThread.joinable()) {
+      configUpdateThread.join();
+    }
+  }
+
+  void _startTimer(nlohmann::json session_params) {
+    if (_configuration->sdkBehaviorSettingsUpdatesDisabled) {
+      _logger->log(LogLevel::INFO, "[ConfigurationModule] _startTimer, SDK behavior settings updates are disabled.");
+      return;
+    }
+
+    if (configUpdateThread.joinable()) {
+      return;
+    }
+
+    stopConfigThread.store(false, std::memory_order_release);
+    configUpdateThread = std::thread(&ConfigurationModule::ConfigurationModuleImpl::_updateConfigPeriodically, this, session_params);
+  }
+
+  ~ConfigurationModuleImpl() {
+    _stopTimer();
+    sdk_behavior_settings.clear();
+
+    networkingEnabled.store(true, std::memory_order_relaxed);
+    trackingEnabled.store(true, std::memory_order_relaxed);
+    sessionTrackingEnabled.store(true, std::memory_order_relaxed);
+    viewTrackingEnabled.store(true, std::memory_order_relaxed);
+    locationTrackingEnabled.store(true, std::memory_order_relaxed);
+    customEventTrackingEnabled.store(true, std::memory_order_relaxed);
+    crashReportingEnabled.store(true, std::memory_order_relaxed);
+    eventQueueThreshold.store(0, std::memory_order_relaxed);
+    requestQueueSizeLimit.store(0, std::memory_order_relaxed);
+    sessionUpdateInterval.store(0, std::memory_order_relaxed);
+    _logger.reset();
+  }
+
+  bool getBool(const char *key, bool defaultValue) const {
+    if (!sdk_behavior_settings.is_object()) {
+      return defaultValue;
+    }
+
+    auto it = sdk_behavior_settings.find(key);
+    if (it == sdk_behavior_settings.end() || !it->is_boolean()) {
+      return defaultValue;
+    }
+
+    bool value = it->get<bool>();
+    return value;
+  }
+
+  unsigned int getUInt(const char *key, unsigned int defaultValue) const {
+    if (!sdk_behavior_settings.is_object()) {
+      return defaultValue;
+    }
+
+    auto it = sdk_behavior_settings.find(key);
+    if (it == sdk_behavior_settings.end() || !it->is_number_unsigned()) {
+      return defaultValue;
+    }
+
+    unsigned int value = it->get<unsigned int>();
+    return value;
+  }
+};
+
+ConfigurationModule::ConfigurationModule(cly::CountlyDelegates *cly, std::shared_ptr<CountlyConfiguration> config, std::shared_ptr<LoggerModule> logger, std::shared_ptr<RequestBuilder> requestBuilder, std::shared_ptr<StorageModuleBase> storageModule, std::shared_ptr<RequestModule> requestModule,
+                                         std::shared_ptr<std::mutex> mutex) {
+  impl.reset(new ConfigurationModuleImpl(cly, config, logger, requestBuilder, storageModule, requestModule, mutex));
+  impl->_logger->log(LogLevel::DEBUG, "[ConfigurationModule] Initialized");
+}
+
+ConfigurationModule::~ConfigurationModule() { impl.reset(); }
+
+void ConfigurationModule::fetchConfigFromServer(nlohmann::json session_params) {
+  impl->_mutex->lock();
+  std::map<std::string, std::string> data = {{"method", "sc"}, {"app_key", session_params["app_key"].get<std::string>()}, {"device_id", session_params["device_id"].get<std::string>()}};
+  impl->_mutex->unlock();
+  // Fetch SBS asynchronously
+  std::thread _thread(&ConfigurationModule::ConfigurationModuleImpl::_fetchConfigFromServerHTTP, impl.get(), data, session_params);
+  _thread.detach();
+}
+
+void ConfigurationModule::fetchConfigFromStorage() {
+  impl->_mutex->lock();
+  impl->_initializeSBSFromStorage();
+  impl->_mutex->unlock();
+}
+
+void ConfigurationModule::startServerConfigUpdateTimer(nlohmann::json session_params) { impl->_startTimer(session_params); }
+
+void ConfigurationModule::stopTimer() { impl->_stopTimer(); }
+
+bool ConfigurationModule::isTrackingEnabled() const { return impl->trackingEnabled.load(std::memory_order_acquire); }
+
+bool ConfigurationModule::isNetworkingEnabled() const { return impl->networkingEnabled.load(std::memory_order_acquire); }
+
+bool ConfigurationModule::isLocationTrackingEnabled() { return impl->locationTrackingEnabled.load(std::memory_order_acquire); }
+
+bool ConfigurationModule::isViewTrackingEnabled() const { return impl->viewTrackingEnabled.load(std::memory_order_acquire); }
+
+bool ConfigurationModule::isSessionTrackingEnabled() { return impl->sessionTrackingEnabled.load(std::memory_order_acquire); }
+
+bool ConfigurationModule::isCustomEventTrackingEnabled() { return impl->customEventTrackingEnabled.load(std::memory_order_acquire); }
+
+bool ConfigurationModule::isCrashReportingEnabled() const { return impl->crashReportingEnabled.load(std::memory_order_acquire); }
+
+unsigned int ConfigurationModule::getRequestQueueSizeLimit() const { return impl->requestQueueSizeLimit.load(std::memory_order_acquire); }
+
+unsigned int ConfigurationModule::getEventQueueSizeLimit() { return impl->eventQueueThreshold.load(std::memory_order_acquire); }
+
+unsigned int ConfigurationModule::getSessionUpdateInterval() { return impl->sessionUpdateInterval.load(std::memory_order_acquire); }
+// namespace cly
+} // namespace cly
\ No newline at end of file
diff --git a/src/countly.cpp b/src/countly.cpp
index bf01fef..3cd1a36 100644
--- a/src/countly.cpp
+++ b/src/countly.cpp
@@ -252,6 +252,11 @@ void Countly::setLocation(double lattitude, double longitude) {
 
 void Countly::setLocation(const std::string &countryCode, const std::string &city, const std::string &gpsCoordinates, const std::string &ipAddress) {
   mutex->lock();
+  if (configurationModule->isLocationTrackingEnabled() == false) {
+    log(LogLevel::ERROR, "[Countly][setLocation] Location tracking is disabled in server configuration, can not set location.");
+    mutex->unlock();
+    return;
+  }
   log(LogLevel::INFO, "[Countly][setLocation] SetLocation : countryCode = " + countryCode + ", city = " + city + ", gpsCoordinates = " + gpsCoordinates + ", ipAddress = " + ipAddress);
 
   if ((!countryCode.empty() && city.empty()) || (!city.empty() && countryCode.empty())) {
@@ -452,9 +457,14 @@ void Countly::start(const std::string &app_key, const std::string &host, int por
 
   requestBuilder.reset(new RequestBuilder(configuration, logger));
   requestModule.reset(new RequestModule(configuration, logger, requestBuilder, storageModule));
+  configurationModule.reset(new cly::ConfigurationModule(this, configuration, logger, requestBuilder, storageModule, requestModule, mutex));
   crash_module.reset(new cly::CrashModule(configuration, logger, requestModule, mutex));
   views_module.reset(new cly::ViewsModule(this, logger));
 
+  requestModule->setConfigurationProvider(configurationModule);
+  views_module->setConfigurationProvider(configurationModule);
+  crash_module->setConfigurationProvider(configurationModule);
+
   bool result = true;
 #ifdef COUNTLY_USE_SQLITE
   result = createEventTableSchema();
@@ -462,6 +472,14 @@ void Countly::start(const std::string &app_key, const std::string &host, int por
 
   is_sdk_initialized = result; // after this point SDK is initialized.
 
+  if (is_sdk_initialized) {
+    mutex->unlock();
+    configurationModule->fetchConfigFromStorage();
+    configurationModule->fetchConfigFromServer(session_params);
+    configurationModule->startServerConfigUpdateTimer(session_params);
+    mutex->lock();
+  }
+
   if (!running) {
 
     if (configuration->manualSessionControl == false) {
@@ -494,6 +512,7 @@ void Countly::startOnCloud(const std::string &app_key) {
 }
 
 void Countly::stop() {
+  configurationModule->stopTimer();
   _deleteThread();
   if (configuration->manualSessionControl == false) {
     endSession();
@@ -521,6 +540,13 @@ void Countly::setUpdateInterval(size_t milliseconds) {
 }
 
 void Countly::addEvent(const cly::Event &event) {
+  if (configurationModule->isCustomEventTrackingEnabled() == false) {
+    std::string eventStr = event.serialize();
+    if (eventStr.find("[CLY]_") == std::string::npos) {
+      log(LogLevel::DEBUG, "[Countly] addEvent, custom event tracking is disabled in server configuration, can not add event with key: " + eventStr);
+      return;
+    }
+  }
   mutex->lock();
 #ifndef COUNTLY_USE_SQLITE
   event_queue.push_back(event.serialize());
@@ -536,7 +562,7 @@ void Countly::checkAndSendEventToRQ() {
   int queueSize = checkEQSize();
   mutex->lock();
 #ifdef COUNTLY_USE_SQLITE
-  if (queueSize >= configuration->eventQueueThreshold) {
+  if (queueSize >= configurationModule->getEventQueueSizeLimit()) {
     log(LogLevel::DEBUG, "Event queue threshold is reached");
     std::string event_ids;
 
@@ -550,7 +576,7 @@ void Countly::checkAndSendEventToRQ() {
     removeEventWithId(event_ids);
   }
 #else
-  if (queueSize >= configuration->eventQueueThreshold) {
+  if (queueSize >= configurationModule->getEventQueueSizeLimit()) {
     log(LogLevel::WARNING, "Event queue is full, dropping the oldest event to insert a new one");
     for (const auto &event_json : event_queue) {
       events.push_back(nlohmann::json::parse(event_json));
@@ -702,6 +728,11 @@ std::vector<std::string> Countly::debugReturnStateOfEQ() {
 bool Countly::beginSession() {
   mutex->lock();
   log(LogLevel::INFO, "[Countly][beginSession]");
+  if (configurationModule->isSessionTrackingEnabled() == false) {
+    log(LogLevel::ERROR, "[Countly][beginSession] Session tracking is disabled in server configuration, can not begin session.");
+    mutex->unlock();
+    return false;
+  }
   if (began_session == true) {
     mutex->unlock();
     log(LogLevel::DEBUG, "[Countly][beginSession] Session is already active.");
@@ -758,6 +789,11 @@ bool Countly::updateSession() {
   try {
     // Check if there was a session, if not try to start one
     mutex->lock();
+    if (configurationModule->isSessionTrackingEnabled() == false) {
+      log(LogLevel::ERROR, "[Countly][updateSession] Session tracking is disabled in server configuration, can not update session.");
+      mutex->unlock();
+      return false;
+    }
     if (began_session == false) {
       mutex->unlock();
       if (configuration->manualSessionControl == true) {
@@ -798,7 +834,7 @@ bool Countly::updateSession() {
     mutex->lock();
 
     // report session duration if it is greater than the configured session duration value
-    if (duration.count() >= configuration->sessionDuration) {
+    if (duration.count() >= configurationModule->getSessionUpdateInterval()) {
       log(LogLevel::DEBUG, "[Countly][updateSession] sending session update.");
       std::map<std::string, std::string> data = {{"app_key", session_params["app_key"].get<std::string>()}, {"device_id", session_params["device_id"].get<std::string>()}, {"session_duration", std::to_string(duration.count())}};
       requestModule->addRequestToQueue(data);
@@ -885,6 +921,11 @@ void Countly::sendEventsToRQ(const nlohmann::json &events) {
 
 bool Countly::endSession() {
   log(LogLevel::INFO, "[Countly][endSession]");
+  if (configurationModule->isSessionTrackingEnabled() == false) {
+    log(LogLevel::ERROR, "[Countly][endSession] Session tracking is disabled in server configuration, can not end session.");
+    mutex->unlock();
+    return false;
+  }
   if (began_session == false) {
     log(LogLevel::DEBUG, "[Countly][endSession] There is no active session to end.");
     return true;
@@ -1245,6 +1286,11 @@ void Countly::enableRemoteConfig() {
 }
 
 void Countly::_fetchRemoteConfig(const std::map<std::string, std::string> &data) {
+  if (configurationModule->isNetworkingEnabled() == false) {
+    log(LogLevel::ERROR, "[Countly] _fetchRemoteConfig, Error fetching remote config, networking is disabled in SBS");
+    return;
+  }
+
   HTTPResponse response = requestModule->sendHTTP("/o/sdk", requestBuilder->serializeData(data));
   mutex->lock();
   if (response.success) {
@@ -1278,6 +1324,11 @@ nlohmann::json Countly::getRemoteConfigValue(const std::string &key) {
 }
 
 void Countly::_updateRemoteConfigWithSpecificValues(const std::map<std::string, std::string> &data) {
+  if (configurationModule->isNetworkingEnabled() == false) {
+    log(LogLevel::ERROR, "[Countly] _updateRemoteConfigWithSpecificValues, Error fetching remote config, networking is disabled in SBS");
+    return;
+  }
+  
   HTTPResponse response = requestModule->sendHTTP("/o/sdk", requestBuilder->serializeData(data));
   mutex->lock();
   if (response.success) {
diff --git a/src/crash_module.cpp b/src/crash_module.cpp
index 319db7f..cca8a16 100644
--- a/src/crash_module.cpp
+++ b/src/crash_module.cpp
@@ -16,6 +16,7 @@ class CrashModule::CrashModuleImpl {
   std::shared_ptr<LoggerModule> _logger;
   std::shared_ptr<RequestModule> _requestModule;
   std::shared_ptr<std::mutex> _mutex;
+  std::weak_ptr<ConfigurationProvider> _configProvider;
   CrashModuleImpl(std::shared_ptr<CountlyConfiguration> config, std::shared_ptr<LoggerModule> logger, std::shared_ptr<RequestModule> requestModule, std::shared_ptr<std::mutex> mutex) : _configuration(config), _logger(logger), _requestModule(requestModule), _mutex(mutex) {}
 
   // destructor to reset logger
@@ -50,6 +51,13 @@ void CrashModule::recordException(const std::string &title, const std::string &s
 
   impl->_logger->log(LogLevel::INFO, cly::utils::format_string("[CrashModule] recordException: title = %s, stackTrace = %s", title.c_str(), stackTrace.c_str()));
 
+  if (std::shared_ptr<ConfigurationProvider> config = impl->_configProvider.lock()) {
+    if (config->isCrashReportingEnabled() == false) {
+      impl->_logger->log(LogLevel::DEBUG, "[CrashModule] recordException: Crash reporting is disabled. Not recording exception.");
+      return;
+    }
+  }
+
   if (title.empty()) {
     impl->_logger->log(LogLevel::WARNING, "[CrashModule] recordException : The parameter 'title' can't be empty");
   }
@@ -94,4 +102,6 @@ void CrashModule::recordException(const std::string &title, const std::string &s
   impl->_mutex->unlock();
 }
 
+void CrashModule::setConfigurationProvider(std::weak_ptr<ConfigurationProvider> provider) { impl->_configProvider = std::move(provider); }
+
 } // namespace cly
\ No newline at end of file
diff --git a/src/request_module.cpp b/src/request_module.cpp
index 1770c86..5032265 100644
--- a/src/request_module.cpp
+++ b/src/request_module.cpp
@@ -12,7 +12,6 @@
 #ifndef COUNTLY_USE_CUSTOM_HTTP
 #ifdef _WIN32
 #include "Windows.h"
-#include "WinHTTP.h"
 #undef ERROR
 #pragma comment(lib, "winhttp.lib")
 #else
@@ -99,19 +98,35 @@ static size_t countly_curl_write_callback(void *data, size_t byte_size, size_t n
 }
 
 void RequestModule::addRequestToQueue(const std::map<std::string, std::string> &data) {
-  if (impl->_configuration->requestQueueThreshold <= impl->_storageModule->RQCount()) {
-    impl->_logger->log(LogLevel::WARNING, cly::utils::format_string("[RequestModule] addRequestToQueue: Request Queue is full. Dropping the oldest request."));
-    impl->_storageModule->RQRemoveFront();
-  }
 
-  const std::string request = impl->_requestBuilder->buildRequest(data);
-  impl->_storageModule->RQInsertAtEnd(request);
+  if (std::shared_ptr<ConfigurationProvider> config = _configProvider.lock()) {
+    if (config->isTrackingEnabled() == false) {
+      impl->_logger->log(LogLevel::DEBUG, "[RequestModule] addRequestToQueue: Tracking is disabled. Not adding request to queue.");
+      return;
+    }
+
+    if (config->getRequestQueueSizeLimit() <= impl->_storageModule->RQCount()) {
+      impl->_logger->log(LogLevel::WARNING, cly::utils::format_string("[RequestModule] addRequestToQueue: Request Queue is full. Dropping the oldest request."));
+      impl->_storageModule->RQRemoveFront();
+    }
+
+    const std::string request = impl->_requestBuilder->buildRequest(data);
+    impl->_storageModule->RQInsertAtEnd(request);
+  }
 }
 
 void RequestModule::clearRequestQueue() { impl->_storageModule->RQClearAll(); }
 
 void RequestModule::processQueue(std::shared_ptr<std::mutex> mutex) {
   mutex->lock();
+
+  if (std::shared_ptr<ConfigurationProvider> config = _configProvider.lock()) {
+    if (config->isNetworkingEnabled() == false) {
+      impl->_logger->log(LogLevel::DEBUG, "[RequestModule] processQueue: Networking is disabled. Not processing request queue.");
+      return;
+    }
+  }
+
   // making sure that no other thread is processing the queue
   if (impl->is_queue_being_processed) {
     mutex->unlock();
@@ -342,4 +357,7 @@ HTTPResponse RequestModule::sendHTTP(std::string path, std::string data) {
 #endif
 }
 long long RequestModule::RQSize() { return impl->_storageModule->RQCount(); }
+
+void RequestModule::setConfigurationProvider(std::weak_ptr<ConfigurationProvider> provider) { _configProvider = std::move(provider); }
+
 } // namespace cly
diff --git a/src/storage_module_db.cpp b/src/storage_module_db.cpp
index 60c73e9..c0dc435 100644
--- a/src/storage_module_db.cpp
+++ b/src/storage_module_db.cpp
@@ -10,6 +10,10 @@
 const char REQUESTS_TABLE_NAME[] = "Requests";
 const char REQUESTS_TABLE_REQUEST_ID[] = "RequestID";
 const char REQUESTS_TABLE_REQUEST_DATA[] = "RequestData";
+#define SDK_BEHAVIOR_SETTINGS_TABLE_NAME "SDKBehaviorSettings"
+#define SDK_BEHAVIOR_SETTINGS_KEY_COLUMN_NAME "Key"
+#define SDK_BEHAVIOR_SETTINGS_DATA_COLUMN_NAME "SettingsData"
+#define SDK_BEHAVIOR_SETTINGS_KEY_VALUE 1
 
 namespace cly {
 StorageModuleDB::StorageModuleDB(std::shared_ptr<CountlyConfiguration> config, std::shared_ptr<LoggerModule> logger) : StorageModuleBase(config, logger) {}
@@ -30,6 +34,8 @@ void StorageModuleDB::init() {
 
     // Create schema for the requests table
     _is_initialized = createSchema(REQUESTS_TABLE_NAME, REQUESTS_TABLE_REQUEST_ID, REQUESTS_TABLE_REQUEST_DATA);
+    // Create schema for the SDK behavior settings table
+    _is_initialized = createSchema(SDK_BEHAVIOR_SETTINGS_TABLE_NAME, SDK_BEHAVIOR_SETTINGS_KEY_COLUMN_NAME, SDK_BEHAVIOR_SETTINGS_DATA_COLUMN_NAME);
 
     if (_is_initialized) {
       vacuumDatabase();
@@ -454,4 +460,90 @@ const std::shared_ptr<DataEntry> StorageModuleDB::RQPeekFront() {
   }
 }
 
+void StorageModuleDB::storeSDKBehaviorSettings(const std::string &sdk_behavior_settings) {
+  if (!_is_initialized) {
+    _logger->log(LogLevel::ERROR, "[Countly][StorageModuleDB] storeSDKBehaviorSettings: Module is not initialized");
+    return;
+  }
+
+  if (sdk_behavior_settings.empty()) {
+    _logger->log(LogLevel::WARNING, "[Countly][StorageModuleDB] storeSDKBehaviorSettings: Empty data");
+    return;
+  }
+
+  _logger->log(LogLevel::DEBUG, "[Countly][StorageModuleDB] storeSDKBehaviorSettings");
+
+#ifdef COUNTLY_USE_SQLITE
+  sqlite3 *db = nullptr;
+  sqlite3_stmt *stmt = nullptr;
+
+  if (sqlite3_open(_configuration->databasePath.c_str(), &db) != SQLITE_OK) {
+    _logger->log(LogLevel::ERROR, "[Countly][StorageModuleDB] Failed to open database");
+    return;
+  }
+
+  const char *sql = "INSERT OR REPLACE INTO " SDK_BEHAVIOR_SETTINGS_TABLE_NAME " (" SDK_BEHAVIOR_SETTINGS_KEY_COLUMN_NAME ", " SDK_BEHAVIOR_SETTINGS_DATA_COLUMN_NAME ") "
+                    "VALUES (?, ?);";
+
+  if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
+    _logger->log(LogLevel::ERROR, "[Countly][StorageModuleDB] Failed to prepare statement");
+    sqlite3_close(db);
+    return;
+  }
+
+  sqlite3_bind_int(stmt, 1, SDK_BEHAVIOR_SETTINGS_KEY_VALUE);
+  sqlite3_bind_text(stmt, 2, sdk_behavior_settings.c_str(), -1, SQLITE_TRANSIENT);
+
+  if (sqlite3_step(stmt) != SQLITE_DONE) {
+  const char* err = sqlite3_errmsg(db);
+  _logger->log(
+    LogLevel::ERROR,
+    std::string("[Countly][StorageModuleDB] storeSDKBehaviorSettings failed: ") +
+    err);  }
+
+  sqlite3_finalize(stmt);
+  sqlite3_close(db);
+#endif
+}
+
+std::string StorageModuleDB::getSDKBehaviorSettings() {
+  if (!_is_initialized) {
+    _logger->log(LogLevel::ERROR, "[Countly][StorageModuleDB] getSDKBehaviorSettings: Module is not initialized");
+    return "";
+  }
+
+#ifdef COUNTLY_USE_SQLITE
+  sqlite3 *db = nullptr;
+  sqlite3_stmt *stmt = nullptr;
+  std::string result;
+
+  if (sqlite3_open(_configuration->databasePath.c_str(), &db) != SQLITE_OK) {
+    _logger->log(LogLevel::ERROR, "[Countly][StorageModuleDB] Failed to open database");
+    return "";
+  }
+
+  const char *sql = "SELECT " SDK_BEHAVIOR_SETTINGS_DATA_COLUMN_NAME " FROM " SDK_BEHAVIOR_SETTINGS_TABLE_NAME " LIMIT 1;";
+
+  if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+    if (sqlite3_step(stmt) == SQLITE_ROW) {
+      const unsigned char *text = sqlite3_column_text(stmt, 0);
+      if (text) {
+        result = reinterpret_cast<const char *>(text);
+      }
+    }
+  } else {
+    _logger->log(LogLevel::ERROR, "[Countly][StorageModuleDB] Failed to prepare statement");
+  }
+
+  if (stmt) {
+    sqlite3_finalize(stmt);
+  }
+  sqlite3_close(db);
+
+  return result;
+#else
+  return "";
+#endif
+}
+
 }; // namespace cly
\ No newline at end of file
diff --git a/src/storage_module_memory.cpp b/src/storage_module_memory.cpp
index eadb4c3..1409653 100644
--- a/src/storage_module_memory.cpp
+++ b/src/storage_module_memory.cpp
@@ -106,6 +106,15 @@ void StorageModuleMemory::RQClearAll() {
   request_queue.clear();
 }
 
+void StorageModuleMemory::storeSDKBehaviorSettings(const std::string &sdk_behavior_settings) {
+  // For in-memory storage, it is already stored in memory inside the module.
+}
+
+std::string StorageModuleMemory::getSDKBehaviorSettings() {
+  // For in-memory storage, it is already stored in memory inside the module.
+  return "";
+}
+
 const std::shared_ptr<DataEntry> StorageModuleMemory::RQPeekFront() {
   std::shared_ptr<DataEntry> front = nullptr;
   if (!_is_initialized) {
diff --git a/src/views_module.cpp b/src/views_module.cpp
index e1a0f4d..ca3d04b 100644
--- a/src/views_module.cpp
+++ b/src/views_module.cpp
@@ -68,11 +68,18 @@ class ViewsModule::ViewModuleImpl {
 
 public:
   std::shared_ptr<cly::LoggerModule> _logger;
+  std::weak_ptr<ConfigurationProvider> _configProvider;
   ViewModuleImpl(cly::CountlyDelegates *cly, std::shared_ptr<cly::LoggerModule> logger) : _cly(cly), _logger(logger) {}
 
   ~ViewModuleImpl() { _logger.reset(); }
 
   std::string _openView(const std::string &name, const std::map<std::string, std::string> &segmentation) {
+    if (std::shared_ptr<ConfigurationProvider> config = _configProvider.lock()) {
+      if (config->isViewTrackingEnabled() == false) {
+        _logger->log(LogLevel::DEBUG, "[ViewsModule] _openView: View tracking is disabled. Not opening view.");
+        return "";
+      }
+    }
     ViewModuleImpl::ViewInfo *v = new ViewModuleImpl::ViewInfo();
     v->name = name;
     v->viewId = cly::utils::generateEventID();
@@ -87,6 +94,12 @@ class ViewsModule::ViewModuleImpl {
   }
 
   void _closeViewWithName(const std::string &name) {
+    if (std::shared_ptr<ConfigurationProvider> config = _configProvider.lock()) {
+      if (config->isViewTrackingEnabled() == false) {
+        _logger->log(LogLevel::DEBUG, "[ViewsModule] _closeViewWithName: View tracking is disabled. Not closing view.");
+        return;
+      }
+    }
     std::shared_ptr<ViewModuleImpl::ViewInfo> v = findViewByName(name);
     if (v == nullptr) {
       _logger->log(cly::LogLevel::WARNING, cly::utils::format_string("[ViewModuleImpl] _closeViewWithName:  Couldn't found "
@@ -98,6 +111,12 @@ class ViewsModule::ViewModuleImpl {
   }
 
   void _closeViewWithID(const std::string &viewId) {
+    if (std::shared_ptr<ConfigurationProvider> config = _configProvider.lock()) {
+      if (config->isViewTrackingEnabled() == false) {
+        _logger->log(LogLevel::DEBUG, "[ViewsModule] _closeViewWithID: View tracking is disabled. Not closing view.");
+        return;
+      }
+    }
 
     if (_viewsStartTime.find(viewId) == _viewsStartTime.end()) {
       _logger->log(cly::LogLevel::WARNING, cly::utils::format_string("[ViewModuleImpl] _closeViewWithID:  Couldn't found "
@@ -150,4 +169,7 @@ void ViewsModule::closeViewWithID(const std::string &viewId) {
 
   impl->_closeViewWithID(viewId);
 }
+
+void ViewsModule::setConfigurationProvider(std::weak_ptr<ConfigurationProvider> provider) { impl->_configProvider = std::move(provider); }
+
 } // namespace cly
\ No newline at end of file