From: Soumya Koduri <skoduri@redhat.com>
Date: Thu, 8 Jul 2021 10:10:34 +0000 (+0530)
Subject: rgw/dbstore: Use dpp for logging
X-Git-Tag: v17.1.0~1246^2~2
X-Git-Url: http://git.apps.os.sepia.ceph.com/?a=commitdiff_plain;h=2a3e3be238698b191f0e89ed7c3f527335e88375;p=ceph-ci.git

rgw/dbstore: Use dpp for logging

Aligning with other Ceph RGW modules, use dpp for logging.
A default dpp is defined for DBStore to be used for unit-tests.

Signed-off-by: Soumya Koduri <skoduri@redhat.com>
---

diff --git a/src/rgw/rgw_sal.cc b/src/rgw/rgw_sal.cc
index 5559ae9dc21..bdd2adc3be5 100644
--- a/src/rgw/rgw_sal.cc
+++ b/src/rgw/rgw_sal.cc
@@ -78,7 +78,7 @@ rgw::sal::Store* StoreManager::init_storage_provider(const DoutPrefixProvider* d
 
   if (svc.compare("dbstore") == 0) {
 #ifdef WITH_RADOSGW_DBSTORE
-    store = newRGWDBStore(cct);
+    rgw::sal::Store* store = newRGWDBStore(cct);
 
     /* Initialize the dbstore with cct & dpp */
     DBStore *db = static_cast<rgw::sal::RGWDBStore *>(store)->getDBStore();
diff --git a/src/rgw/rgw_sal_dbstore.cc b/src/rgw/rgw_sal_dbstore.cc
index 3d5ad098aac..fb2e668c0ab 100644
--- a/src/rgw/rgw_sal_dbstore.cc
+++ b/src/rgw/rgw_sal_dbstore.cc
@@ -39,7 +39,7 @@ namespace rgw::sal {
     int ret;
 
     buckets.clear();
-    ret = store->getDBStore()->list_buckets(info.user_id, marker, end_marker, max,
+    ret = store->getDBStore()->list_buckets(dpp, info.user_id, marker, end_marker, max,
         need_stats, &ulist, &is_truncated);
     if (ret < 0)
       return ret;
@@ -61,7 +61,7 @@ namespace rgw::sal {
   int DBUser::read_attrs(const DoutPrefixProvider* dpp, optional_yield y)
   {
     int ret;
-    ret = store->getDBStore()->get_user(string("user_id"), "", info, &attrs,
+    ret = store->getDBStore()->get_user(dpp, string("user_id"), "", info, &attrs,
         &objv_tracker);
     return ret;
   }
@@ -101,7 +101,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->get_user(string("user_id"), "", info, &attrs,
+    ret = store->getDBStore()->get_user(dpp, string("user_id"), "", info, &attrs,
         &objv_tracker);
 
     return ret;
@@ -111,7 +111,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->store_user(info, exclusive, &attrs, &objv_tracker, old_info);
+    ret = store->getDBStore()->store_user(dpp, info, exclusive, &attrs, &objv_tracker, old_info);
 
     return ret;
   }
@@ -120,7 +120,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->remove_user(info, &objv_tracker);
+    ret = store->getDBStore()->remove_user(dpp, info, &objv_tracker);
 
     return ret;
   }
@@ -140,7 +140,7 @@ namespace rgw::sal {
 
     /* XXX: handle delete_children */
 
-    ret = store->getDBStore()->remove_bucket(info);
+    ret = store->getDBStore()->remove_bucket(dpp, info);
 
     return ret;
   }
@@ -149,7 +149,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->get_bucket_info(string("name"), "", info, &attrs,
+    ret = store->getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
         &mtime, &bucket_version);
 
     return ret;
@@ -193,7 +193,7 @@ namespace rgw::sal {
   {
     int ret;
 
-    ret = store->getDBStore()->update_bucket("owner", info, false, &(new_user->get_id()), nullptr, nullptr, nullptr);
+    ret = store->getDBStore()->update_bucket(dpp, "owner", info, false, &(new_user->get_id()), nullptr, nullptr, nullptr);
 
     /* XXX: Update policies of all the bucket->objects with new user */
     return ret;
@@ -203,7 +203,7 @@ namespace rgw::sal {
   {
     int ret;
 
-    ret = store->getDBStore()->update_bucket("info", info, exclusive, nullptr, nullptr, &_mtime, &info.objv_tracker);
+    ret = store->getDBStore()->update_bucket(dpp, "info", info, exclusive, nullptr, nullptr, &_mtime, &info.objv_tracker);
 
     return ret;
 
@@ -214,7 +214,7 @@ namespace rgw::sal {
     /* XXX: same as DBBUcket::remove_bucket() but should return error if there are objects
      * in that bucket. */
 
-    int ret = store->getDBStore()->remove_bucket(info);
+    int ret = store->getDBStore()->remove_bucket(dpp, info);
 
     return ret;
   }
@@ -244,7 +244,7 @@ namespace rgw::sal {
 
     /* XXX: handle has_instance_obj like in set_bucket_instance_attrs() */
 
-    ret = store->getDBStore()->update_bucket("attrs", info, false, nullptr, &attrs, nullptr, &get_info().objv_tracker);
+    ret = store->getDBStore()->update_bucket(dpp, "attrs", info, false, nullptr, &attrs, nullptr, &get_info().objv_tracker);
 
     return ret;
   }
@@ -253,7 +253,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->get_bucket_info(string("name"), "", info, &attrs,
+    ret = store->getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
         pmtime, &bucket_version);
 
     return ret;
@@ -319,7 +319,7 @@ namespace rgw::sal {
     Attrs attrs = get_attrs();
     attrs[RGW_ATTR_ACL] = aclbl;
 
-    ret = store->getDBStore()->update_bucket("attrs", info, false, &(acl.get_owner().get_id()), &attrs, nullptr, nullptr);
+    ret = store->getDBStore()->update_bucket(dpp, "attrs", info, false, &(acl.get_owner().get_id()), &attrs, nullptr, nullptr);
 
     return ret;
   }
@@ -449,7 +449,7 @@ namespace rgw::sal {
     int ret = 0;
     RGWObjVersionTracker objv_tracker;
 
-    ret = getDBStore()->get_user(string("access_key"), key, uinfo, nullptr,
+    ret = getDBStore()->get_user(dpp, string("access_key"), key, uinfo, nullptr,
         &objv_tracker);
 
     if (ret < 0)
@@ -473,7 +473,7 @@ namespace rgw::sal {
     int ret = 0;
     RGWObjVersionTracker objv_tracker;
 
-    ret = getDBStore()->get_user(string("email"), email, uinfo, nullptr,
+    ret = getDBStore()->get_user(dpp, string("email"), email, uinfo, nullptr,
         &objv_tracker);
 
     if (ret < 0)
@@ -618,11 +618,10 @@ namespace rgw::sal {
     } else {
 
       /* XXX: We may not need to send all these params. Cleanup the unused ones */
-      ret = getDBStore()->create_bucket(u->get_info(), bucket->get_key(),
+      ret = getDBStore()->create_bucket(dpp, u->get_info(), bucket->get_key(),
           zid, placement_rule, swift_ver_location, pquota_info,
           attrs, info, pobjv, &ep_objv, creation_time,
-          pmaster_bucket, pmaster_num_shards, y, dpp,
-          exclusive);
+          pmaster_bucket, pmaster_num_shards, y, exclusive);
       if (ret == -EEXIST) {
         *existed = true;
         ret = 0;
@@ -684,7 +683,7 @@ namespace rgw::sal {
 
   std::unique_ptr<Notification> RGWDBStore::get_notification(rgw::sal::Object* obj,
       struct req_state* s,
-      rgw::notify::EventType event_type)
+      rgw::notify::EventType event_type, const std::string* object_name)
   {
     return 0;
   }
@@ -759,7 +758,7 @@ namespace rgw::sal {
 
       RGWBucketInfo info;
       map<string, bufferlist> attrs;
-      int r = getDBStore()->get_bucket_info(string("name"), "", info, &attrs,
+      int r = getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
           nullptr, nullptr);
       if (r < 0) {
         ldpp_dout(dpp, 0) << "NOTICE: get_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
@@ -772,7 +771,7 @@ namespace rgw::sal {
         info.flags |= BUCKET_SUSPENDED;
       }
 
-      r = getDBStore()->update_bucket("info", info, false, nullptr, &attrs, nullptr, &info.objv_tracker);
+      r = getDBStore()->update_bucket(dpp, "info", info, false, nullptr, &attrs, nullptr, &info.objv_tracker);
       if (r < 0) {
         ldpp_dout(dpp, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
         ret = r;
diff --git a/src/rgw/rgw_sal_dbstore.h b/src/rgw/rgw_sal_dbstore.h
index 818752fcca2..8a68a4b26a5 100644
--- a/src/rgw/rgw_sal_dbstore.h
+++ b/src/rgw/rgw_sal_dbstore.h
@@ -285,7 +285,8 @@ namespace rgw { namespace sal {
       virtual int cluster_stat(RGWClusterStat& stats) override;
       virtual std::unique_ptr<Lifecycle> get_lifecycle(void) override;
       virtual std::unique_ptr<Completions> get_completions(void) override;
-      virtual std::unique_ptr<Notification> get_notification(rgw::sal::Object* obj, struct req_state* s, rgw::notify::EventType event_type) override;
+      virtual std::unique_ptr<Notification> get_notification(rgw::sal::Object* obj, struct req_state* s, 
+          rgw::notify::EventType event_type, const std::string* object_name=nullptr) override;
       virtual std::unique_ptr<GCChain> get_gc_chain(rgw::sal::Object* obj) override;
       virtual std::unique_ptr<Writer> get_writer(Aio *aio, rgw::sal::Bucket* bucket,
           RGWObjectCtx& obj_ctx, std::unique_ptr<rgw::sal::Object> _head_obj,
diff --git a/src/rgw/store/dbstore/common/dbstore.cc b/src/rgw/store/dbstore/common/dbstore.cc
index 0587c6fdbb2..230c9ca75be 100644
--- a/src/rgw/store/dbstore/common/dbstore.cc
+++ b/src/rgw/store/dbstore/common/dbstore.cc
@@ -14,6 +14,7 @@ map<string, class ObjectOp*> DBStore::getObjectMap() {
 int DBStore::Initialize(string logfile, int loglevel)
 {
   int ret = -1;
+  const DoutPrefixProvider *dpp = get_def_dpp();
 
   if (!cct) {
     cout << "Failed to Initialize. No ceph Context \n";
@@ -29,100 +30,100 @@ int DBStore::Initialize(string logfile, int loglevel)
   }
 
 
-  db = openDB();
+  db = openDB(dpp);
 
   if (!db) {
-    dbout(cct, 0) <<"Failed to open database " << dbendl;
+    ldpp_dout(dpp, 0) <<"Failed to open database " << dendl;
     return ret;
   }
 
-  ret = LockInit();
+  ret = LockInit(dpp);
 
   if (ret) {
-    dbout(cct, 0) <<"Error: mutex is NULL " << dbendl;
-    closeDB();
+    ldpp_dout(dpp, 0) <<"Error: mutex is NULL " << dendl;
+    closeDB(dpp);
     db = NULL;
     return ret;
   }
 
-  ret = InitializeDBOps();
+  ret = InitializeDBOps(dpp);
 
   if (ret) {
-    dbout(cct, 0) <<"InitializeDBOps failed " << dbendl;
-    LockDestroy();
-    closeDB();
+    ldpp_dout(dpp, 0) <<"InitializeDBOps failed " << dendl;
+    LockDestroy(dpp);
+    closeDB(dpp);
     db = NULL;
     return ret;
   }
 
-  dbout(cct, 0) << "DBStore successfully initialized - name:" \
-    << db_name << "" << dbendl;
+  ldpp_dout(dpp, 0) << "DBStore successfully initialized - name:" \
+    << db_name << "" << dendl;
 
   return ret;
 }
 
-int DBStore::Destroy()
+int DBStore::Destroy(const DoutPrefixProvider *dpp)
 {
   if (!db)
     return 0;
 
-  closeDB();
+  closeDB(dpp);
 
-  LockDestroy();
+  LockDestroy(dpp);
 
-  FreeDBOps();
+  FreeDBOps(dpp);
 
-  dbout(cct, 20)<<"DBStore successfully destroyed - name:" \
-    <<db_name << dbendl;
+  ldpp_dout(dpp, 20)<<"DBStore successfully destroyed - name:" \
+    <<db_name << dendl;
 
   return 0;
 }
 
-int DBStore::LockInit() {
+int DBStore::LockInit(const DoutPrefixProvider *dpp) {
   int ret;
 
   ret = pthread_mutex_init(&mutex, NULL);
 
   if (ret)
-    dbout(cct, 0)<<"pthread_mutex_init failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"pthread_mutex_init failed " << dendl;
 
   return ret;
 }
 
-int DBStore::LockDestroy() {
+int DBStore::LockDestroy(const DoutPrefixProvider *dpp) {
   int ret;
 
   ret = pthread_mutex_destroy(&mutex);
 
   if (ret)
-    dbout(cct, 0)<<"pthread_mutex_destroy failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"pthread_mutex_destroy failed " << dendl;
 
   return ret;
 }
 
-int DBStore::Lock() {
+int DBStore::Lock(const DoutPrefixProvider *dpp) {
   int ret;
 
   ret = pthread_mutex_lock(&mutex);
 
   if (ret)
-    dbout(cct, 0)<<"pthread_mutex_lock failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"pthread_mutex_lock failed " << dendl;
 
   return ret;
 }
 
-int DBStore::Unlock() {
+int DBStore::Unlock(const DoutPrefixProvider *dpp) {
   int ret;
 
   ret = pthread_mutex_unlock(&mutex);
 
   if (ret)
-    dbout(cct, 0)<<"pthread_mutex_unlock failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"pthread_mutex_unlock failed " << dendl;
 
   return ret;
 }
 
-DBOp * DBStore::getDBOp(string Op, struct DBOpParams *params)
+DBOp *DBStore::getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params)
 {
   if (!Op.compare("InsertUser"))
     return dbops.InsertUser;
@@ -148,8 +149,8 @@ DBOp * DBStore::getDBOp(string Op, struct DBOpParams *params)
   iter = DBStore::objectmap.find(params->op.bucket.info.bucket.name);
 
   if (iter == DBStore::objectmap.end()) {
-    dbout(cct, 30)<<"No objectmap found for bucket: " \
-      <<params->op.bucket.info.bucket.name << dbendl;
+    ldpp_dout(dpp, 30)<<"No objectmap found for bucket: " \
+      <<params->op.bucket.info.bucket.name << dendl;
     /* not found */
     return NULL;
   }
@@ -172,7 +173,7 @@ DBOp * DBStore::getDBOp(string Op, struct DBOpParams *params)
   return NULL;
 }
 
-int DBStore::objectmapInsert(string bucket, void *ptr)
+int DBStore::objectmapInsert(const DoutPrefixProvider *dpp, string bucket, void *ptr)
 {
   map<string, class ObjectOp*>::iterator iter;
   class ObjectOp *Ob;
@@ -184,20 +185,20 @@ int DBStore::objectmapInsert(string bucket, void *ptr)
     // return success or replace it or
     // return error ?
     // return success for now
-    dbout(cct, 20)<<"Objectmap entry already exists for bucket("\
-      <<bucket<<"). Not inserted " << dbendl;
+    ldpp_dout(dpp, 20)<<"Objectmap entry already exists for bucket("\
+      <<bucket<<"). Not inserted " << dendl;
     return 0;
   }
 
   Ob = (class ObjectOp*) ptr;
-  Ob->InitializeObjectOps();
+  Ob->InitializeObjectOps(dpp);
 
   DBStore::objectmap.insert(pair<string, class ObjectOp*>(bucket, Ob));
 
   return 0;
 }
 
-int DBStore::objectmapDelete(string bucket)
+int DBStore::objectmapDelete(const DoutPrefixProvider *dpp, string bucket)
 {
   map<string, class ObjectOp*>::iterator iter;
   class ObjectOp *Ob;
@@ -208,20 +209,20 @@ int DBStore::objectmapDelete(string bucket)
     // entry doesn't exist
     // return success or return error ?
     // return success for now
-    dbout(cct, 20)<<"Objectmap entry for bucket("<<bucket<<") "
-      <<"doesnt exist to delete " << dbendl;
+    ldpp_dout(dpp, 20)<<"Objectmap entry for bucket("<<bucket<<") "
+      <<"doesnt exist to delete " << dendl;
     return 0;
   }
 
   Ob = (class ObjectOp*) (iter->second);
-  Ob->FreeObjectOps();
+  Ob->FreeObjectOps(dpp);
 
   DBStore::objectmap.erase(iter);
 
   return 0;
 }
 
-int DBStore::InitializeParams(string Op, DBOpParams *params)
+int DBStore::InitializeParams(const DoutPrefixProvider *dpp, string Op, DBOpParams *params)
 {
   int ret = -1;
 
@@ -239,33 +240,34 @@ out:
   return ret;
 }
 
-int DBStore::ProcessOp(string Op, struct DBOpParams *params) {
+int DBStore::ProcessOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params) {
   int ret = -1;
   class DBOp *db_op;
 
-  Lock();
-  db_op = getDBOp(Op, params);
+  Lock(dpp);
+  db_op = getDBOp(dpp, Op, params);
 
   if (!db_op) {
-    dbout(cct, 0)<<"No db_op found for Op("<<Op<<")" << dbendl;
-    Unlock();
+    ldpp_dout(dpp, 0)<<"No db_op found for Op("<<Op<<")" << dendl;
+    Unlock(dpp);
     return ret;
   }
-  ret = db_op->Execute(params);
+  ret = db_op->Execute(dpp, params);
 
-  Unlock();
+  Unlock(dpp);
   if (ret) {
-    dbout(cct, 0)<<"In Process op Execute failed for fop(" \
-      <<Op.c_str()<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"In Process op Execute failed for fop(" \
+      <<Op.c_str()<<") " << dendl;
   } else {
-    dbout(cct, 20)<<"Successfully processed fop(" \
-      <<Op.c_str()<<") " << dbendl;
+    ldpp_dout(dpp, 20)<<"Successfully processed fop(" \
+      <<Op.c_str()<<") " << dendl;
   }
 
   return ret;
 }
 
-int DBStore::get_user(const std::string& query_str, const std::string& query_str_val,
+int DBStore::get_user(const DoutPrefixProvider *dpp,
+    const std::string& query_str, const std::string& query_str_val,
     RGWUserInfo& uinfo, map<string, bufferlist> *pattrs,
     RGWObjVersionTracker *pobjv_tracker) {
   int ret = 0;
@@ -277,7 +279,7 @@ int DBStore::get_user(const std::string& query_str, const std::string& query_str
   }
 
   DBOpParams params = {};
-  InitializeParams("GetUser", &params);
+  InitializeParams(dpp, "GetUser", &params);
 
   params.op.query_str = query_str;
 
@@ -294,11 +296,11 @@ int DBStore::get_user(const std::string& query_str, const std::string& query_str
   } else if (query_str == "user_id") {
     params.op.user.uinfo.user_id = uinfo.user_id;
   } else {
-    dbout(cct, 0)<<"In GetUser Invalid query string :" <<query_str.c_str()<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"In GetUser Invalid query string :" <<query_str.c_str()<<") " << dendl;
     return -1;
   }
 
-  ret = ProcessOp("GetUser", &params);
+  ret = ProcessOp(dpp, "GetUser", &params);
 
   if (ret)
     goto out;
@@ -317,11 +319,12 @@ out:
   return ret;
 }
 
-int DBStore::store_user(RGWUserInfo& uinfo, bool exclusive, map<string, bufferlist> *pattrs,
+int DBStore::store_user(const DoutPrefixProvider *dpp,
+    RGWUserInfo& uinfo, bool exclusive, map<string, bufferlist> *pattrs,
     RGWObjVersionTracker *pobjv, RGWUserInfo* pold_info)
 {
   DBOpParams params = {};
-  InitializeParams("CreateUser", &params);
+  InitializeParams(dpp, "CreateUser", &params);
   int ret = 0;
 
   /* Check if the user already exists and return the old info, caller will have a use for it */
@@ -330,7 +333,7 @@ int DBStore::store_user(RGWUserInfo& uinfo, bool exclusive, map<string, bufferli
   obj_version& obj_ver = objv_tracker.read_version;
 
   orig_info.user_id = uinfo.user_id;
-  ret = get_user(string("user_id"), "", orig_info, nullptr, &objv_tracker);
+  ret = get_user(dpp, string("user_id"), "", orig_info, nullptr, &objv_tracker);
 
   if (!ret && obj_ver.ver) {
     /* already exists. */
@@ -342,7 +345,7 @@ int DBStore::store_user(RGWUserInfo& uinfo, bool exclusive, map<string, bufferli
     if (pobjv && (pobjv->read_version.ver != obj_ver.ver)) {
       /* Object version mismatch.. return ECANCELED */
       ret = -ECANCELED;
-      dbout(cct, 0)<<"User Read version mismatch err:(" <<ret<<") " << dbendl;
+      ldpp_dout(dpp, 0)<<"User Read version mismatch err:(" <<ret<<") " << dendl;
       return ret;
     }
 
@@ -363,10 +366,10 @@ int DBStore::store_user(RGWUserInfo& uinfo, bool exclusive, map<string, bufferli
     params.op.user.user_attrs = *pattrs;
   }
 
-  ret = ProcessOp("InsertUser", &params);
+  ret = ProcessOp(dpp, "InsertUser", &params);
 
   if (ret) {
-    dbout(cct, 0)<<"store_user failed with err:(" <<ret<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"store_user failed with err:(" <<ret<<") " << dendl;
     goto out;
   }
 
@@ -379,17 +382,18 @@ out:
   return ret;
 }
 
-int DBStore::remove_user(RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv)
+int DBStore::remove_user(const DoutPrefixProvider *dpp,
+    RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv)
 {
   DBOpParams params = {};
-  InitializeParams("CreateUser", &params);
+  InitializeParams(dpp, "CreateUser", &params);
   int ret = 0;
 
   RGWUserInfo orig_info;
   RGWObjVersionTracker objv_tracker = {};
 
   orig_info.user_id = uinfo.user_id;
-  ret = get_user(string("user_id"), "", orig_info, nullptr, &objv_tracker);
+  ret = get_user(dpp, string("user_id"), "", orig_info, nullptr, &objv_tracker);
 
   if (!ret && objv_tracker.read_version.ver) {
     /* already exists. */
@@ -397,17 +401,17 @@ int DBStore::remove_user(RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv)
     if (pobjv && (pobjv->read_version.ver != objv_tracker.read_version.ver)) {
       /* Object version mismatch.. return ECANCELED */
       ret = -ECANCELED;
-      dbout(cct, 0)<<"User Read version mismatch err:(" <<ret<<") " << dbendl;
+      ldpp_dout(dpp, 0)<<"User Read version mismatch err:(" <<ret<<") " << dendl;
       return ret;
     }
   }
 
   params.op.user.uinfo.user_id = uinfo.user_id;
 
-  ret = ProcessOp("RemoveUser", &params);
+  ret = ProcessOp(dpp, "RemoveUser", &params);
 
   if (ret) {
-    dbout(cct, 0)<<"remove_user failed with err:(" <<ret<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"remove_user failed with err:(" <<ret<<") " << dendl;
     goto out;
   }
 
@@ -415,7 +419,7 @@ out:
   return ret;
 }
 
-int DBStore::get_bucket_info(const std::string& query_str,
+int DBStore::get_bucket_info(const DoutPrefixProvider *dpp, const std::string& query_str,
     const std::string& query_str_val,
     RGWBucketInfo& info,
     rgw::sal::Attrs* pattrs, ceph::real_time* pmtime,
@@ -430,19 +434,19 @@ int DBStore::get_bucket_info(const std::string& query_str,
 
   DBOpParams params = {};
   DBOpParams params2 = {};
-  InitializeParams("GetBucket", &params);
+  InitializeParams(dpp, "GetBucket", &params);
 
   if (query_str == "name") {
     params.op.bucket.info.bucket.name = info.bucket.name;
   } else {
-    dbout(cct, 0)<<"In GetBucket Invalid query string :" <<query_str.c_str()<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"In GetBucket Invalid query string :" <<query_str.c_str()<<") " << dendl;
     return -1;
   }
 
-  ret = ProcessOp("GetBucket", &params);
+  ret = ProcessOp(dpp, "GetBucket", &params);
 
   if (ret) {
-    dbout(cct, 0)<<"In GetBucket failed err:(" <<ret<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"In GetBucket failed err:(" <<ret<<") " << dendl;
     goto out;
   }
 
@@ -466,7 +470,8 @@ out:
   return ret;
 }
 
-int DBStore::create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
+int DBStore::create_bucket(const DoutPrefixProvider *dpp,
+    const RGWUserInfo& owner, rgw_bucket& bucket,
     const string& zonegroup_id,
     const rgw_placement_rule& placement_rule,
     const string& swift_ver_location,
@@ -479,7 +484,6 @@ int DBStore::create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
     rgw_bucket *pmaster_bucket,
     uint32_t *pmaster_num_shards,
     optional_yield y,
-    const DoutPrefixProvider *dpp,
     bool exclusive)
 {
   /*
@@ -491,13 +495,13 @@ int DBStore::create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
    */
 
   DBOpParams params = {};
-  InitializeParams("CreateBucket", &params);
+  InitializeParams(dpp, "CreateBucket", &params);
   int ret = 0;
 
   /* Check if the bucket already exists and return the old info, caller will have a use for it */
   RGWBucketInfo orig_info;
   orig_info.bucket.name = bucket.name;
-  ret = get_bucket_info(string("name"), "", orig_info, nullptr, nullptr, nullptr);
+  ret = get_bucket_info(dpp, string("name"), "", orig_info, nullptr, nullptr, nullptr);
 
   if (!ret && !orig_info.owner.id.empty() && exclusive) {
     /* already exists. Return the old info */
@@ -544,10 +548,10 @@ int DBStore::create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
   params.op.bucket.mtime = ceph::real_time();
   params.op.user.uinfo.user_id.id = owner.user_id.id;
 
-  ret = ProcessOp("InsertBucket", &params);
+  ret = ProcessOp(dpp, "InsertBucket", &params);
 
   if (ret) {
-    dbout(cct, 0)<<"create_bucket failed with err:(" <<ret<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"create_bucket failed with err:(" <<ret<<") " << dendl;
     goto out;
   }
 
@@ -555,18 +559,18 @@ out:
   return ret;
 }
 
-int DBStore::remove_bucket(const RGWBucketInfo info) {
+int DBStore::remove_bucket(const DoutPrefixProvider *dpp, const RGWBucketInfo info) {
   int ret = 0;
 
   DBOpParams params = {};
-  InitializeParams("RemoveBucket", &params);
+  InitializeParams(dpp, "RemoveBucket", &params);
 
   params.op.bucket.info.bucket.name = info.bucket.name;
 
-  ret = ProcessOp("RemoveBucket", &params);
+  ret = ProcessOp(dpp, "RemoveBucket", &params);
 
   if (ret) {
-    dbout(cct, 0)<<"In RemoveBucket failed err:(" <<ret<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"In RemoveBucket failed err:(" <<ret<<") " << dendl;
     goto out;
   }
 
@@ -574,7 +578,7 @@ out:
   return ret;
 }
 
-int DBStore::list_buckets(const rgw_user& user,
+int DBStore::list_buckets(const DoutPrefixProvider *dpp, const rgw_user& user,
     const string& marker,
     const string& end_marker,
     uint64_t max,
@@ -585,17 +589,17 @@ int DBStore::list_buckets(const rgw_user& user,
   int ret = 0;
 
   DBOpParams params = {};
-  InitializeParams("ListUserBuckets", &params);
+  InitializeParams(dpp, "ListUserBuckets", &params);
 
   params.op.user.uinfo.user_id = user;
   params.op.bucket.min_marker = marker;
   params.op.bucket.max_marker = end_marker;
   params.op.list_max_count = max;
 
-  ret = ProcessOp("ListUserBuckets", &params);
+  ret = ProcessOp(dpp, "ListUserBuckets", &params);
 
   if (ret) {
-    dbout(cct, 0)<<"In ListUserBuckets failed err:(" <<ret<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"In ListUserBuckets failed err:(" <<ret<<") " << dendl;
     goto out;
   }
 
@@ -617,7 +621,7 @@ out:
   return ret;
 }
 
-int DBStore::update_bucket(const std::string& query_str,
+int DBStore::update_bucket(const DoutPrefixProvider *dpp, const std::string& query_str,
     RGWBucketInfo& info,
     bool exclusive,
     const rgw_user* powner_id,
@@ -633,11 +637,11 @@ int DBStore::update_bucket(const std::string& query_str,
   /* Check if the bucket already exists and return the old info, caller will have a use for it */
   orig_info.bucket.name = info.bucket.name;
   params.op.bucket.info.bucket.name = info.bucket.name;
-  ret = get_bucket_info(string("name"), "", orig_info, nullptr, nullptr,
+  ret = get_bucket_info(dpp, string("name"), "", orig_info, nullptr, nullptr,
       &bucket_version);
 
   if (ret) {
-    dbout(cct, 0)<<"Failed to read bucket info err:(" <<ret<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"Failed to read bucket info err:(" <<ret<<") " << dendl;
     goto out;
   }
 
@@ -651,7 +655,7 @@ int DBStore::update_bucket(const std::string& query_str,
   /* Verify if the objv read_ver matches current bucket version */
   if (pobjv) {
     if (pobjv->read_version.ver != bucket_version.ver) {
-      dbout(cct, 0)<<"Read version mismatch err:(" <<ret<<") " << dbendl;
+      ldpp_dout(dpp, 0)<<"Read version mismatch err:(" <<ret<<") " << dendl;
       ret = -ECANCELED;
       goto out;
     }
@@ -659,7 +663,7 @@ int DBStore::update_bucket(const std::string& query_str,
     pobjv = &info.objv_tracker;
   }
 
-  InitializeParams("UpdateBucket", &params);
+  InitializeParams(dpp, "UpdateBucket", &params);
 
   params.op.bucket.info.bucket.name = info.bucket.name;
 
@@ -691,14 +695,14 @@ int DBStore::update_bucket(const std::string& query_str,
     params.op.bucket.info = info;
   } else {
     ret = -1;
-    dbout(cct, 0)<<"In UpdateBucket Invalid query_str : " << query_str << dbendl;
+    ldpp_dout(dpp, 0)<<"In UpdateBucket Invalid query_str : " << query_str << dendl;
     goto out;
   }
 
-  ret = ProcessOp("UpdateBucket", &params);
+  ret = ProcessOp(dpp, "UpdateBucket", &params);
 
   if (ret) {
-    dbout(cct, 0)<<"In UpdateBucket failed err:(" <<ret<<") " << dbendl;
+    ldpp_dout(dpp, 0)<<"In UpdateBucket failed err:(" <<ret<<") " << dendl;
     goto out;
   }
 
diff --git a/src/rgw/store/dbstore/common/dbstore.h b/src/rgw/store/dbstore/common/dbstore.h
index a670e9edd8c..3c4d8279190 100644
--- a/src/rgw/store/dbstore/common/dbstore.h
+++ b/src/rgw/store/dbstore/common/dbstore.h
@@ -209,8 +209,8 @@ class ObjectOp {
     class GetObjectDataOp *GetObjectData;
     class DeleteObjectDataOp *DeleteObjectData;
 
-    virtual int InitializeObjectOps() { return 0; }
-    virtual int FreeObjectOps() { return 0; }
+    virtual int InitializeObjectOps(const DoutPrefixProvider *dpp) { return 0; }
+    virtual int FreeObjectOps(const DoutPrefixProvider *dpp) { return 0; }
 };
 
 class DBOp {
@@ -370,7 +370,7 @@ class DBOp {
         return fmt::format(CreateQuotaTableQ.c_str(),
             params->quota_table.c_str());
 
-      dbout(params->cct, 0) << "Incorrect table type("<<type<<") specified" << dbendl;
+      ldout(params->cct, 0) << "Incorrect table type("<<type<<") specified" << dendl;
 
       return NULL;
     }
@@ -382,8 +382,8 @@ class DBOp {
       return fmt::format(ListAllQ.c_str(), table.c_str());
     }
 
-    virtual int Prepare(DBOpParams *params) { return 0; }
-    virtual int Execute(DBOpParams *params) { return 0; }
+    virtual int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params) { return 0; }
+    virtual int Execute(const DoutPrefixProvider *dpp, DBOpParams *params) { return 0; }
 };
 
 class InsertUserOp : public DBOp {
@@ -764,6 +764,7 @@ class DBStore {
   protected:
     void *db;
     CephContext *cct;
+    const DoutPrefix dp;
     uint64_t max_bucket_id = 0;
 
   public:	
@@ -771,7 +772,8 @@ class DBStore {
     user_table(db_name+".user.table"),
     bucket_table(db_name+".bucket.table"),
     quota_table(db_name+".quota.table"),
-    cct(_cct)
+    cct(_cct),
+    dp(_cct, dout_subsys, "rgw DBStore backend: ")
   {}
     /*	DBStore() {}*/
 
@@ -779,7 +781,8 @@ class DBStore {
     user_table("user.table"),
     bucket_table("bucket.table"),
     quota_table("quota.table"),
-    cct(_cct)
+    cct(_cct),
+    dp(_cct, dout_subsys, "rgw DBStore backend: ")
   {}
     virtual	~DBStore() {}
 
@@ -797,41 +800,47 @@ class DBStore {
     }
 
     CephContext *ctx() { return cct; }
+    const DoutPrefixProvider *get_def_dpp() { return &dp; }
+
     int Initialize(string logfile, int loglevel);
-    int Destroy();
-    int LockInit();
-    int LockDestroy();
-    int Lock();
-    int Unlock();
-
-    int InitializeParams(string Op, DBOpParams *params);
-    int ProcessOp(string Op, DBOpParams *params);
-    DBOp* getDBOp(string Op, struct DBOpParams *params);
-    int objectmapInsert(string bucket, void *ptr);
-    int objectmapDelete(string bucket);
-
-    virtual void *openDB() { return NULL; }
-    virtual int closeDB() { return 0; }
-    virtual int createTables() { return 0; }
-    virtual int InitializeDBOps() { return 0; }
-    virtual int FreeDBOps() { return 0; }
-    virtual int InitPrepareParams(DBOpPrepareParams &params) = 0;
-
-    virtual int ListAllBuckets(DBOpParams *params) = 0;
-    virtual int ListAllUsers(DBOpParams *params) = 0;
-    virtual int ListAllObjects(DBOpParams *params) = 0;
-
-    int get_user(const std::string& query_str, const std::string& query_str_val,
+    int Destroy(const DoutPrefixProvider *dpp);
+    int LockInit(const DoutPrefixProvider *dpp);
+    int LockDestroy(const DoutPrefixProvider *dpp);
+    int Lock(const DoutPrefixProvider *dpp);
+    int Unlock(const DoutPrefixProvider *dpp);
+
+    int InitializeParams(const DoutPrefixProvider *dpp, string Op, DBOpParams *params);
+    int ProcessOp(const DoutPrefixProvider *dpp, string Op, DBOpParams *params);
+    DBOp* getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params);
+    int objectmapInsert(const DoutPrefixProvider *dpp, string bucket, void *ptr);
+    int objectmapDelete(const DoutPrefixProvider *dpp, string bucket);
+
+    virtual void *openDB(const DoutPrefixProvider *dpp) { return NULL; }
+    virtual int closeDB(const DoutPrefixProvider *dpp) { return 0; }
+    virtual int createTables(const DoutPrefixProvider *dpp) { return 0; }
+    virtual int InitializeDBOps(const DoutPrefixProvider *dpp) { return 0; }
+    virtual int FreeDBOps(const DoutPrefixProvider *dpp) { return 0; }
+    virtual int InitPrepareParams(const DoutPrefixProvider *dpp, DBOpPrepareParams &params) = 0;
+
+    virtual int ListAllBuckets(const DoutPrefixProvider *dpp, DBOpParams *params) = 0;
+    virtual int ListAllUsers(const DoutPrefixProvider *dpp, DBOpParams *params) = 0;
+    virtual int ListAllObjects(const DoutPrefixProvider *dpp, DBOpParams *params) = 0;
+
+    int get_user(const DoutPrefixProvider *dpp,
+        const std::string& query_str, const std::string& query_str_val,
         RGWUserInfo& uinfo, map<string, bufferlist> *pattrs,
         RGWObjVersionTracker *pobjv_tracker);
-    int store_user(RGWUserInfo& uinfo, bool exclusive, map<string, bufferlist> *pattrs,
+    int store_user(const DoutPrefixProvider *dpp,
+        RGWUserInfo& uinfo, bool exclusive, map<string, bufferlist> *pattrs,
         RGWObjVersionTracker *pobjv_tracker, RGWUserInfo* pold_info);
-    int remove_user(RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv_tracker);
-    int get_bucket_info(const std::string& query_str,
+    int remove_user(const DoutPrefixProvider *dpp,
+        RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv_tracker);
+    int get_bucket_info(const DoutPrefixProvider *dpp, const std::string& query_str,
         const std::string& query_str_val,
         RGWBucketInfo& info, rgw::sal::Attrs* pattrs, ceph::real_time* pmtime,
         obj_version* pbucket_version);
-    int create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
+    int create_bucket(const DoutPrefixProvider *dpp,
+        const RGWUserInfo& owner, rgw_bucket& bucket,
         const string& zonegroup_id,
         const rgw_placement_rule& placement_rule,
         const string& swift_ver_location,
@@ -844,20 +853,20 @@ class DBStore {
         rgw_bucket *pmaster_bucket,
         uint32_t *pmaster_num_shards,
         optional_yield y,
-        const DoutPrefixProvider *dpp,
         bool exclusive);
 
     int next_bucket_id() { return ++max_bucket_id; };
 
-    int remove_bucket(const RGWBucketInfo info);
-    int list_buckets(const rgw_user& user,
+    int remove_bucket(const DoutPrefixProvider *dpp, const RGWBucketInfo info);
+    int list_buckets(const DoutPrefixProvider *dpp, const rgw_user& user,
         const string& marker,
         const string& end_marker,
         uint64_t max,
         bool need_stats,
         RGWUserBuckets *buckets,
         bool *is_truncated);
-    int update_bucket(const std::string& query_str, RGWBucketInfo& info, bool exclusive,
+    int update_bucket(const DoutPrefixProvider *dpp, const std::string& query_str,
+        RGWBucketInfo& info, bool exclusive,
         const rgw_user* powner_id, map<std::string, bufferlist>* pattrs,
         ceph::real_time* pmtime, RGWObjVersionTracker* pobjv);
 };
diff --git a/src/rgw/store/dbstore/common/dbstore_log.h b/src/rgw/store/dbstore/common/dbstore_log.h
index fec41f0c02a..9bd4a227480 100644
--- a/src/rgw/store/dbstore/common/dbstore_log.h
+++ b/src/rgw/store/dbstore/common/dbstore_log.h
@@ -18,10 +18,4 @@ using namespace std;
 #undef dout_prefix
 #define dout_prefix *_dout << "rgw dbstore: "
 
-#define dbout_prefix(cct, v) dout_impl(cct, dout_subsys, v) dout_prefix
-#define dbendl_impl  dendl      
-
-#define dbout(cct, v) dbout_prefix(cct, v)
-#define dbendl dbendl_impl
-
 #endif
diff --git a/src/rgw/store/dbstore/dbstore_main.cc b/src/rgw/store/dbstore/dbstore_main.cc
index c2f09f16dd9..ad6bab7eecd 100644
--- a/src/rgw/store/dbstore/dbstore_main.cc
+++ b/src/rgw/store/dbstore/dbstore_main.cc
@@ -37,8 +37,9 @@ void* process(void *arg)
   string objectc2 = "cns";
 
   struct DBOpParams params = {};
+  const DoutPrefixProvider *dpp = db->get_def_dpp();
 
-  db->InitializeParams("InsertUser", &params);
+  db->InitializeParams(dpp, "InsertUser", &params);
 
   params.op.user.uinfo.display_name = user1;
   params.op.user.uinfo.user_id.tenant = "tenant";
@@ -54,15 +55,15 @@ void* process(void *arg)
   params.op.user.uinfo.access_keys.insert(make_pair("key1", k1));
   params.op.user.uinfo.access_keys.insert(make_pair("key2", k2));
 
-  ret = db->ProcessOp("InsertUser", &params);
+  ret = db->ProcessOp(dpp, "InsertUser", &params);
   cout << "InsertUser return value: " <<  ret << "\n";
 
   struct DBOpParams params2 = {};
   params.op.user.uinfo.user_id.tenant = "tenant2";
 
-  db->InitializeParams("GetUser", &params2);
+  db->InitializeParams(dpp, "GetUser", &params2);
   params2.op.user.uinfo.display_name = user1;
-  ret = db->ProcessOp("GetUser", &params2);
+  ret = db->ProcessOp(dpp, "GetUser", &params2);
 
   cout << "GetUser return value: " <<  ret << "\n";
 
@@ -87,30 +88,30 @@ void* process(void *arg)
   }
 
   params.op.bucket.info.bucket.name = bucketa;
-  db->ProcessOp("InsertBucket", &params);
+  db->ProcessOp(dpp, "InsertBucket", &params);
 
   params.op.user.uinfo.display_name = user2;
   params.op.user.uinfo.user_id.id = user2;
-  db->ProcessOp("InsertUser", &params);
+  db->ProcessOp(dpp, "InsertUser", &params);
 
   params.op.bucket.info.bucket.name = bucketb;
-  db->ProcessOp("InsertBucket", &params);
+  db->ProcessOp(dpp, "InsertBucket", &params);
 
-  db->ProcessOp("GetUser", &params);
-  db->ProcessOp("GetBucket", &params);
+  db->ProcessOp(dpp, "GetUser", &params);
+  db->ProcessOp(dpp, "GetBucket", &params);
 
-  db->ListAllUsers(&params);
-  db->ListAllBuckets(&params);
+  db->ListAllUsers(dpp, &params);
+  db->ListAllBuckets(dpp, &params);
 
   params.op.bucket.info.bucket.name = bucketb;
 
-  db->ProcessOp("RemoveBucket", &params);
+  db->ProcessOp(dpp, "RemoveBucket", &params);
 
   params.op.user.uinfo.user_id.id = user2;
-  db->ProcessOp("RemoveUser", &params);
+  db->ProcessOp(dpp, "RemoveUser", &params);
 
-  db->ListAllUsers(&params);
-  db->ListAllBuckets(&params);
+  db->ListAllUsers(dpp, &params);
+  db->ListAllBuckets(dpp, &params);
   cout<<"Exiting thread:"<<thr_id<<"\n";
 
   return 0;
diff --git a/src/rgw/store/dbstore/dbstore_mgr.cc b/src/rgw/store/dbstore/dbstore_mgr.cc
index 9a96c5c3faa..f033035611b 100644
--- a/src/rgw/store/dbstore/dbstore_mgr.cc
+++ b/src/rgw/store/dbstore/dbstore_mgr.cc
@@ -91,7 +91,7 @@ void DBStoreManager::deleteDBStore(string tenant) {
   dbs = iter->second;
 
   DBStoreHandles.erase(iter);
-  dbs->Destroy();
+  dbs->Destroy(dbs->get_def_dpp());
   delete dbs;
 
   return;
@@ -115,7 +115,7 @@ void DBStoreManager::destroyAllHandles(){
   for (iter = DBStoreHandles.begin(); iter != DBStoreHandles.end();
       ++iter) {
     dbs = iter->second;
-    dbs->Destroy();
+    dbs->Destroy(dbs->get_def_dpp());
     delete dbs;
   }
 
diff --git a/src/rgw/store/dbstore/dbstore_mgr.h b/src/rgw/store/dbstore/dbstore_mgr.h
index 307efd8ba9e..9744b4f0239 100644
--- a/src/rgw/store/dbstore/dbstore_mgr.h
+++ b/src/rgw/store/dbstore/dbstore_mgr.h
@@ -33,9 +33,10 @@ public:
 	default_dbstore = createDBStore(default_tenant);
   };
   DBStoreManager(string logfile, int loglevel): DBStoreHandles() {
+    /* No ceph context. Create one with log args provided */
     vector<const char*> args;
     cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
-                        CODE_ENVIRONMENT_UTILITY, 1)->get();
+                      CODE_ENVIRONMENT_DAEMON, CINIT_FLAG_NO_MON_CONFIG, 1)->get();
     cct->_log->set_log_file(logfile);
     cct->_log->reopen_log_file();
     cct->_conf->subsys.set_log_level(dout_subsys, loglevel);
diff --git a/src/rgw/store/dbstore/sqlite/sqliteDB.cc b/src/rgw/store/dbstore/sqlite/sqliteDB.cc
index 136aa17f78f..5ed710b1da2 100644
--- a/src/rgw/store/dbstore/sqlite/sqliteDB.cc
+++ b/src/rgw/store/dbstore/sqlite/sqliteDB.cc
@@ -3,138 +3,138 @@
 
 #include "sqliteDB.h"
 
-#define SQL_PREPARE(cct, params, sdb, stmt, ret, Op) 	\
+#define SQL_PREPARE(dpp, params, sdb, stmt, ret, Op) 	\
   do {							\
     string schema;			   		\
     schema = Schema(params);	   		\
     sqlite3_prepare_v2 (*sdb, schema.c_str(), 	\
         -1, &stmt , NULL);		\
     if (!stmt) {					\
-      dbout(cct, 0) <<"failed to prepare statement " \
+      ldpp_dout(dpp, 0) <<"failed to prepare statement " \
       <<"for Op("<<Op<<"); Errmsg -"\
-      <<sqlite3_errmsg(*sdb)<< dbendl;\
+      <<sqlite3_errmsg(*sdb)<< dendl;\
       ret = -1;				\
       goto out;				\
     }						\
-    dbout(cct, 20)<<"Successfully Prepared stmt for Op("<<Op	\
-    <<") schema("<<schema<<") stmt("<<stmt<<")"<< dbendl;	\
+    ldpp_dout(dpp, 20)<<"Successfully Prepared stmt for Op("<<Op	\
+    <<") schema("<<schema<<") stmt("<<stmt<<")"<< dendl;	\
     ret = 0;					\
   } while(0);
 
-#define SQL_BIND_INDEX(cct, stmt, index, str, sdb)	\
+#define SQL_BIND_INDEX(dpp, stmt, index, str, sdb)	\
   do {						\
     index = sqlite3_bind_parameter_index(stmt, str);     \
     \
     if (index <=0)  {				     \
-      dbout(cct, 0) <<"failed to fetch bind parameter"\
+      ldpp_dout(dpp, 0) <<"failed to fetch bind parameter"\
       " index for str("<<str<<") in "   \
       <<"stmt("<<stmt<<"); Errmsg -"    \
-      <<sqlite3_errmsg(*sdb)<< dbendl; 	     \
+      <<sqlite3_errmsg(*sdb)<< dendl; 	     \
       rc = -1;				     \
       goto out;				     \
     }						     \
-    dbout(cct, 20)<<"Bind parameter index for str("  \
+    ldpp_dout(dpp, 20)<<"Bind parameter index for str("  \
     <<str<<") in stmt("<<stmt<<") is "  \
-    <<index<< dbendl;			     \
+    <<index<< dendl;			     \
   }while(0);
 
-#define SQL_BIND_TEXT(cct, stmt, index, str, sdb)			\
+#define SQL_BIND_TEXT(dpp, stmt, index, str, sdb)			\
   do {								\
     rc = sqlite3_bind_text(stmt, index, str, -1, SQLITE_TRANSIENT); 	\
     \
     if (rc != SQLITE_OK) {					      	\
-      dbout(cct, 0)<<"sqlite bind text failed for index("     	\
+      ldpp_dout(dpp, 0)<<"sqlite bind text failed for index("     	\
       <<index<<"), str("<<str<<") in stmt("   	\
       <<stmt<<"); Errmsg - "<<sqlite3_errmsg(*sdb) \
-      << dbendl;				\
+      << dendl;				\
       rc = -1;					\
       goto out;					\
     }							\
   }while(0);
 
-#define SQL_BIND_INT(cct, stmt, index, num, sdb)			\
+#define SQL_BIND_INT(dpp, stmt, index, num, sdb)			\
   do {								\
     rc = sqlite3_bind_int(stmt, index, num);		\
     \
     if (rc != SQLITE_OK) {					\
-      dbout(cct, 0)<<"sqlite bind int failed for index("     	\
+      ldpp_dout(dpp, 0)<<"sqlite bind int failed for index("     	\
       <<index<<"), num("<<num<<") in stmt("   	\
       <<stmt<<"); Errmsg - "<<sqlite3_errmsg(*sdb) \
-      << dbendl;				\
+      << dendl;				\
       rc = -1;					\
       goto out;					\
     }							\
   }while(0);
 
-#define SQL_BIND_BLOB(cct, stmt, index, blob, size, sdb)		\
+#define SQL_BIND_BLOB(dpp, stmt, index, blob, size, sdb)		\
   do {								\
     rc = sqlite3_bind_blob(stmt, index, blob, size, SQLITE_TRANSIENT);  \
     \
     if (rc != SQLITE_OK) {					\
-      dbout(cct, 0)<<"sqlite bind blob failed for index("     	\
+      ldpp_dout(dpp, 0)<<"sqlite bind blob failed for index("     	\
       <<index<<"), blob("<<blob<<") in stmt("   	\
       <<stmt<<"); Errmsg - "<<sqlite3_errmsg(*sdb) \
-      << dbendl;				\
+      << dendl;				\
       rc = -1;					\
       goto out;					\
     }							\
   }while(0);
 
-#define SQL_ENCODE_BLOB_PARAM(cct, stmt, index, param, sdb)		\
+#define SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, param, sdb)		\
   do {								\
     bufferlist b;						\
     encode(param, b);					\
-    SQL_BIND_BLOB(cct, stmt, index, b.c_str(), b.length(), sdb); \
+    SQL_BIND_BLOB(dpp, stmt, index, b.c_str(), b.length(), sdb); \
   }while(0);
 
-#define SQL_READ_BLOB(cct, stmt, index, void_ptr, len)		\
+#define SQL_READ_BLOB(dpp, stmt, index, void_ptr, len)		\
   do {								\
     void_ptr = NULL;					\
     void_ptr = (void *)sqlite3_column_blob(stmt, index);	\
     len = sqlite3_column_bytes(stmt, index);		\
     \
     if (!void_ptr || len == 0) {				\
-      dbout(cct, 20)<<"Null value for blob index("  \
-      <<index<<") in stmt("<<stmt<<") "<< dbendl;   \
+      ldpp_dout(dpp, 20)<<"Null value for blob index("  \
+      <<index<<") in stmt("<<stmt<<") "<< dendl;   \
     }							\
   }while(0);
 
-#define SQL_DECODE_BLOB_PARAM(cct, stmt, index, param, sdb)		\
+#define SQL_DECODE_BLOB_PARAM(dpp, stmt, index, param, sdb)		\
   do {								\
     bufferlist b;						\
     void *blob;						\
     int blob_len = 0;					\
     \
-    SQL_READ_BLOB(cct, stmt, index, blob, blob_len);		\
+    SQL_READ_BLOB(dpp, stmt, index, blob, blob_len);		\
     \
     b.append(reinterpret_cast<char *>(blob), blob_len);	\
     \
     decode(param, b);					\
   }while(0);
 
-#define SQL_EXECUTE(params, stmt, cbk, args...) \
+#define SQL_EXECUTE(dpp, params, stmt, cbk, args...) \
   do{						\
     if (!stmt) {				\
-      ret = Prepare(params);		\
+      ret = Prepare(dpp, params);		\
     }					\
     \
     if (!stmt) {				\
-      dbout(cct, 0) <<"No prepared statement "<< dbendl;	\
+      ldpp_dout(dpp, 0) <<"No prepared statement "<< dendl;	\
       goto out;			\
     }					\
     \
-    ret = Bind(params);			\
+    ret = Bind(dpp, params);			\
     if (ret) {				\
-      dbout(cct, 0) <<"Bind parameters failed for stmt(" <<stmt<<") "<< dbendl;		\
+      ldpp_dout(dpp, 0) <<"Bind parameters failed for stmt(" <<stmt<<") "<< dendl;		\
       goto out;			\
     }					\
     \
-    ret = Step(params->op, stmt, cbk);		\
+    ret = Step(dpp, params->op, stmt, cbk);		\
     \
-    Reset(stmt);				\
+    Reset(dpp, stmt);				\
     \
     if (ret) {				\
-      dbout(cct, 0) <<"Execution failed for stmt(" <<stmt<<")"<< dbendl;		\
+      ldpp_dout(dpp, 0) <<"Execution failed for stmt(" <<stmt<<")"<< dendl;		\
       goto out;			\
     }					\
   }while(0);
@@ -212,11 +212,11 @@ enum GetBucket {
   Bucket_User_NS
 };
 
-static int list_user(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
+static int list_user(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *stmt) {
   if (!stmt)
     return -1;
 
-  //cout<<sqlite3_column_text(stmt, 0) << dbendl;
+  //cout<<sqlite3_column_text(stmt, 0) << dendl;
   /* Ensure the column names match with the user table defined in dbstore.h                     
      UserID TEXT ,		\ - 0
      Tenant TEXT ,		\ - 1
@@ -251,15 +251,15 @@ static int list_user(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
   op.user.uinfo.display_name = (const char*)sqlite3_column_text(stmt, DisplayName); // user_name
   op.user.uinfo.user_email = (const char*)sqlite3_column_text(stmt, UserEmail);
 
-  SQL_DECODE_BLOB_PARAM(cct, stmt, AccessKeys, op.user.uinfo.access_keys, sdb);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, SwiftKeys, op.user.uinfo.swift_keys, sdb);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, SubUsers, op.user.uinfo.subusers, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, AccessKeys, op.user.uinfo.access_keys, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, SwiftKeys, op.user.uinfo.swift_keys, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, SubUsers, op.user.uinfo.subusers, sdb);
 
   op.user.uinfo.suspended = sqlite3_column_int(stmt, Suspended);
   op.user.uinfo.max_buckets = sqlite3_column_int(stmt, MaxBuckets);
   op.user.uinfo.op_mask = sqlite3_column_int(stmt, OpMask);
 
-  SQL_DECODE_BLOB_PARAM(cct, stmt, UserCaps, op.user.uinfo.caps, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, UserCaps, op.user.uinfo.caps, sdb);
 
   op.user.uinfo.admin = sqlite3_column_int(stmt, Admin);
   op.user.uinfo.system = sqlite3_column_int(stmt, System);
@@ -268,31 +268,31 @@ static int list_user(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
 
   op.user.uinfo.default_placement.storage_class = (const char*)sqlite3_column_text(stmt, PlacementStorageClass);
 
-  SQL_DECODE_BLOB_PARAM(cct, stmt, PlacementTags, op.user.uinfo.placement_tags, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, PlacementTags, op.user.uinfo.placement_tags, sdb);
 
-  SQL_DECODE_BLOB_PARAM(cct, stmt, BucketQuota, op.user.uinfo.bucket_quota, sdb);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, TempURLKeys, op.user.uinfo.temp_url_keys, sdb);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, UserQuota, op.user.uinfo.user_quota, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, BucketQuota, op.user.uinfo.bucket_quota, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, TempURLKeys, op.user.uinfo.temp_url_keys, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, UserQuota, op.user.uinfo.user_quota, sdb);
 
   op.user.uinfo.type = sqlite3_column_int(stmt, TYPE);
 
-  SQL_DECODE_BLOB_PARAM(cct, stmt, MfaIDs, op.user.uinfo.mfa_ids, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, MfaIDs, op.user.uinfo.mfa_ids, sdb);
 
   op.user.uinfo.assumed_role_arn = (const char*)sqlite3_column_text(stmt, AssumedRoleARN);
 
-  SQL_DECODE_BLOB_PARAM(cct, stmt, UserAttrs, op.user.user_attrs, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, UserAttrs, op.user.user_attrs, sdb);
   op.user.user_version.ver = sqlite3_column_int(stmt, UserVersion);
   op.user.user_version.tag = (const char*)sqlite3_column_text(stmt, UserVersionTag);
 
   return 0;
 }
 
-static int list_bucket(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
+static int list_bucket(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *stmt) {
   if (!stmt)
     return -1;
 
  // cout<<sqlite3_column_text(stmt, 0)<<", ";
- // cout<<sqlite3_column_text(stmt, 1) << dbendl;
+ // cout<<sqlite3_column_text(stmt, 1) << dendl;
 
   op.bucket.ent.bucket.name = (const char*)sqlite3_column_text(stmt, BucketName);
   op.bucket.ent.bucket.tenant = (const char*)sqlite3_column_text(stmt, Bucket_Tenant);
@@ -300,7 +300,7 @@ static int list_bucket(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
   op.bucket.ent.bucket.bucket_id = (const char*)sqlite3_column_text(stmt, BucketID);
   op.bucket.ent.size = sqlite3_column_int(stmt, Size);
   op.bucket.ent.size_rounded = sqlite3_column_int(stmt, SizeRounded);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, CreationTime, op.bucket.ent.creation_time, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, CreationTime, op.bucket.ent.creation_time, sdb);
   op.bucket.ent.count = sqlite3_column_int(stmt, Count);
   op.bucket.ent.placement_rule.name = (const char*)sqlite3_column_text(stmt, Bucket_PlacementName);
   op.bucket.ent.placement_rule.storage_class = (const char*)sqlite3_column_text(stmt, Bucket_PlacementStorageClass);
@@ -320,17 +320,17 @@ static int list_bucket(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
   op.bucket.info.zonegroup = (const char*)sqlite3_column_text(stmt, Zonegroup);
   op.bucket.info.has_instance_obj = sqlite3_column_int(stmt, HasInstanceObj);
 
-  SQL_DECODE_BLOB_PARAM(cct, stmt, Quota, op.bucket.info.quota, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, Quota, op.bucket.info.quota, sdb);
   op.bucket.info.requester_pays = sqlite3_column_int(stmt, RequesterPays);
   op.bucket.info.has_website = sqlite3_column_int(stmt, HasWebsite);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, WebsiteConf, op.bucket.info.website_conf, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, WebsiteConf, op.bucket.info.website_conf, sdb);
   op.bucket.info.swift_versioning = sqlite3_column_int(stmt, SwiftVersioning);
   op.bucket.info.swift_ver_location = (const char*)sqlite3_column_text(stmt, SwiftVerLocation);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, MdsearchConfig, op.bucket.info.mdsearch_config, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, MdsearchConfig, op.bucket.info.mdsearch_config, sdb);
   op.bucket.info.new_bucket_instance_id = (const char*)sqlite3_column_text(stmt, NewBucketInstanceID);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, ObjectLock, op.bucket.info.obj_lock, sdb);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, SyncPolicyInfoGroups, op.bucket.info.sync_policy, sdb);
-  SQL_DECODE_BLOB_PARAM(cct, stmt, BucketAttrs, op.bucket.bucket_attrs, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, ObjectLock, op.bucket.info.obj_lock, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, SyncPolicyInfoGroups, op.bucket.info.sync_policy, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, BucketAttrs, op.bucket.bucket_attrs, sdb);
   op.bucket.bucket_version.ver = sqlite3_column_int(stmt, BucketVersion);
   op.bucket.bucket_version.tag = (const char*)sqlite3_column_text(stmt, BucketVersionTag);
 
@@ -340,24 +340,24 @@ static int list_bucket(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
   op.bucket.info.objv_tracker.read_version = op.bucket.bucket_version;
   op.bucket.info.objv_tracker.write_version = op.bucket.bucket_version;
 
-  SQL_DECODE_BLOB_PARAM(cct, stmt, Mtime, op.bucket.mtime, sdb);
+  SQL_DECODE_BLOB_PARAM(dpp, stmt, Mtime, op.bucket.mtime, sdb);
 
   op.bucket.list_entries.push_back(op.bucket.ent);
 
   return 0;
 }
 
-static int list_object(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
+static int list_object(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *stmt) {
   if (!stmt)
     return -1;
 
  // cout<<sqlite3_column_text(stmt, 0)<<", ";
- // cout<<sqlite3_column_text(stmt, 1) << dbendl;
+ // cout<<sqlite3_column_text(stmt, 1) << dendl;
 
   return 0;
 }
 
-static int get_objectdata(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
+static int get_objectdata(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *stmt) {
   if (!stmt)
     return -1;
 
@@ -374,14 +374,14 @@ static int get_objectdata(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt) {
   if (blob)
     strncpy(data, (const char *)blob, datalen);
 
-//  cout<<data<<","<<datalen << dbendl;
+//  cout<<data<<","<<datalen << dendl;
 
   return 0;
 }
 
-int SQLiteDB::InitializeDBOps()
+int SQLiteDB::InitializeDBOps(const DoutPrefixProvider *dpp)
 {
-  (void)createTables();
+  (void)createTables(dpp);
   dbops.InsertUser = new SQLInsertUser(&this->db, cct);
   dbops.RemoveUser = new SQLRemoveUser(&this->db, cct);
   dbops.GetUser = new SQLGetUser(&this->db, cct);
@@ -394,7 +394,7 @@ int SQLiteDB::InitializeDBOps()
   return 0;
 }
 
-int SQLiteDB::FreeDBOps()
+int SQLiteDB::FreeDBOps(const DoutPrefixProvider *dpp)
 {
   delete dbops.InsertUser;
   delete dbops.RemoveUser;
@@ -408,14 +408,14 @@ int SQLiteDB::FreeDBOps()
   return 0;
 }
 
-void *SQLiteDB::openDB()
+void *SQLiteDB::openDB(const DoutPrefixProvider *dpp)
 {
   string dbname;
   int rc = 0;
 
   dbname = getDBname();
   if (dbname.empty()) {
-    dbout(cct, 0)<<"dbname is NULL" << dbendl;
+    ldpp_dout(dpp, 0)<<"dbname is NULL" << dendl;
     goto out;
   }
 
@@ -426,19 +426,19 @@ void *SQLiteDB::openDB()
       NULL);
 
   if (rc) {
-    dbout(cct, 0) <<"Cant open "<<dbname<<"; Errmsg - "\
-      <<sqlite3_errmsg((sqlite3*)db) <<  dbendl;
+    ldpp_dout(dpp, 0) <<"Cant open "<<dbname<<"; Errmsg - "\
+      <<sqlite3_errmsg((sqlite3*)db) <<  dendl;
   } else {
-    dbout(cct, 0) <<"Opened database("<<dbname<<") successfully" <<  dbendl;
+    ldpp_dout(dpp, 0) <<"Opened database("<<dbname<<") successfully" <<  dendl;
   }
 
-  exec("PRAGMA foreign_keys=ON", NULL);
+  exec(dpp, "PRAGMA foreign_keys=ON", NULL);
 
 out:
   return db;
 }
 
-int SQLiteDB::closeDB()
+int SQLiteDB::closeDB(const DoutPrefixProvider *dpp)
 {
   if (db)
     sqlite3_close((sqlite3 *)db);
@@ -448,7 +448,7 @@ int SQLiteDB::closeDB()
   return 0;
 }
 
-int SQLiteDB::Reset(sqlite3_stmt *stmt)
+int SQLiteDB::Reset(const DoutPrefixProvider *dpp, sqlite3_stmt *stmt)
 {
   int ret = -1;
 
@@ -461,8 +461,8 @@ int SQLiteDB::Reset(sqlite3_stmt *stmt)
   return ret;
 }
 
-int SQLiteDB::Step(DBOpInfo &op, sqlite3_stmt *stmt,
-    int (*cbk)(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt))
+int SQLiteDB::Step(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *stmt,
+    int (*cbk)(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *stmt))
 {
   int ret = -1;
 
@@ -474,24 +474,24 @@ again:
   ret = sqlite3_step(stmt);
 
   if ((ret != SQLITE_DONE) && (ret != SQLITE_ROW)) {
-    dbout(cct, 0)<<"sqlite step failed for stmt("<<stmt \
-      <<"); Errmsg - "<<sqlite3_errmsg((sqlite3*)db) << dbendl;
+    ldpp_dout(dpp, 0)<<"sqlite step failed for stmt("<<stmt \
+      <<"); Errmsg - "<<sqlite3_errmsg((sqlite3*)db) << dendl;
     return -1;
   } else if (ret == SQLITE_ROW) {
     if (cbk) {
-      (*cbk)(ctx(), op, stmt);
+      (*cbk)(dpp, op, stmt);
     } else {
     }
     goto again;
   }
 
-  dbout(cct, 20)<<"sqlite step successfully executed for stmt(" \
-    <<stmt<<")  ret = " << ret << dbendl;
+  ldpp_dout(dpp, 20)<<"sqlite step successfully executed for stmt(" \
+    <<stmt<<")  ret = " << ret << dendl;
 
   return 0;
 }
 
-int SQLiteDB::exec(const char *schema,
+int SQLiteDB::exec(const DoutPrefixProvider *dpp, const char *schema,
     int (*callback)(void*,int,char**,char**))
 {
   int ret = -1;
@@ -502,19 +502,19 @@ int SQLiteDB::exec(const char *schema,
 
   ret = sqlite3_exec((sqlite3*)db, schema, callback, 0, &errmsg);
   if (ret != SQLITE_OK) {
-    dbout(cct, 0) <<"sqlite exec failed for schema("<<schema \
-      <<"); Errmsg - "<<errmsg <<  dbendl;
+    ldpp_dout(dpp, 0) <<"sqlite exec failed for schema("<<schema \
+      <<"); Errmsg - "<<errmsg <<  dendl;
     sqlite3_free(errmsg);
     goto out;
   }
   ret = 0;
-  dbout(cct, 10) <<"sqlite exec successfully processed for schema(" \
-    <<schema<<")" <<  dbendl;
+  ldpp_dout(dpp, 10) <<"sqlite exec successfully processed for schema(" \
+    <<schema<<")" <<  dendl;
 out:
   return ret;
 }
 
-int SQLiteDB::createTables()
+int SQLiteDB::createTables(const DoutPrefixProvider *dpp)
 {
   int ret = -1;
   int cu, cb = -1;
@@ -523,206 +523,206 @@ int SQLiteDB::createTables()
   params.user_table = getUserTable();
   params.bucket_table = getBucketTable();
 
-  if ((cu = createUserTable(&params)))
+  if ((cu = createUserTable(dpp, &params)))
     goto out;
 
-  if ((cb = createBucketTable(&params)))
+  if ((cb = createBucketTable(dpp, &params)))
     goto out;
 
-  if ((cb = createQuotaTable(&params)))
+  if ((cb = createQuotaTable(dpp, &params)))
     goto out;
 
   ret = 0;
 out:
   if (ret) {
     if (cu)
-      DeleteUserTable(&params);
+      DeleteUserTable(dpp, &params);
     if (cb)
-      DeleteBucketTable(&params);
-    dbout(cct, 0)<<"Creation of tables failed" << dbendl;
+      DeleteBucketTable(dpp, &params);
+    ldpp_dout(dpp, 0)<<"Creation of tables failed" << dendl;
   }
 
   return ret;
 }
 
-int SQLiteDB::createUserTable(DBOpParams *params)
+int SQLiteDB::createUserTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = CreateTableSchema("User", params);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"CreateUserTable failed" << dbendl;
+    ldpp_dout(dpp, 0)<<"CreateUserTable failed" << dendl;
 
-  dbout(cct, 20)<<"CreateUserTable suceeded" << dbendl;
+  ldpp_dout(dpp, 20)<<"CreateUserTable suceeded" << dendl;
 
   return ret;
 }
 
-int SQLiteDB::createBucketTable(DBOpParams *params)
+int SQLiteDB::createBucketTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = CreateTableSchema("Bucket", params);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"CreateBucketTable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"CreateBucketTable failed " << dendl;
 
-  dbout(cct, 20)<<"CreateBucketTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"CreateBucketTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::createObjectTable(DBOpParams *params)
+int SQLiteDB::createObjectTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = CreateTableSchema("Object", params);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"CreateObjectTable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"CreateObjectTable failed " << dendl;
 
-  dbout(cct, 20)<<"CreateObjectTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"CreateObjectTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::createQuotaTable(DBOpParams *params)
+int SQLiteDB::createQuotaTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = CreateTableSchema("Quota", params);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"CreateQuotaTable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"CreateQuotaTable failed " << dendl;
 
-  dbout(cct, 20)<<"CreateQuotaTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"CreateQuotaTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::createObjectDataTable(DBOpParams *params)
+int SQLiteDB::createObjectDataTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = CreateTableSchema("ObjectData", params);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"CreateObjectDataTable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"CreateObjectDataTable failed " << dendl;
 
-  dbout(cct, 20)<<"CreateObjectDataTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"CreateObjectDataTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::DeleteUserTable(DBOpParams *params)
+int SQLiteDB::DeleteUserTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = DeleteTableSchema(params->user_table);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"DeleteUserTable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"DeleteUserTable failed " << dendl;
 
-  dbout(cct, 20)<<"DeleteUserTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"DeleteUserTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::DeleteBucketTable(DBOpParams *params)
+int SQLiteDB::DeleteBucketTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = DeleteTableSchema(params->bucket_table);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"DeletebucketTable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"DeletebucketTable failed " << dendl;
 
-  dbout(cct, 20)<<"DeletebucketTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"DeletebucketTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::DeleteObjectTable(DBOpParams *params)
+int SQLiteDB::DeleteObjectTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = DeleteTableSchema(params->object_table);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"DeleteObjectTable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"DeleteObjectTable failed " << dendl;
 
-  dbout(cct, 20)<<"DeleteObjectTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"DeleteObjectTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::DeleteObjectDataTable(DBOpParams *params)
+int SQLiteDB::DeleteObjectDataTable(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = DeleteTableSchema(params->objectdata_table);
 
-  ret = exec(schema.c_str(), NULL);
+  ret = exec(dpp, schema.c_str(), NULL);
   if (ret)
-    dbout(cct, 0)<<"DeleteObjectDataTable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"DeleteObjectDataTable failed " << dendl;
 
-  dbout(cct, 20)<<"DeleteObjectDataTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"DeleteObjectDataTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::ListAllUsers(DBOpParams *params)
+int SQLiteDB::ListAllUsers(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = ListTableSchema(params->user_table);
- // cout<<"########### Listing all Users #############" << dbendl;
-  ret = exec(schema.c_str(), &list_callback);
+ // cout<<"########### Listing all Users #############" << dendl;
+  ret = exec(dpp, schema.c_str(), &list_callback);
   if (ret)
-    dbout(cct, 0)<<"GetUsertable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"GetUsertable failed " << dendl;
 
-  dbout(cct, 20)<<"GetUserTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"GetUserTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::ListAllBuckets(DBOpParams *params)
+int SQLiteDB::ListAllBuckets(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
 
   schema = ListTableSchema(params->bucket_table);
 
-//  cout<<"########### Listing all Buckets #############" << dbendl;
-  ret = exec(schema.c_str(), &list_callback);
+//  cout<<"########### Listing all Buckets #############" << dendl;
+  ret = exec(dpp, schema.c_str(), &list_callback);
   if (ret)
-    dbout(cct, 0)<<"Listbuckettable failed " << dbendl;
+    ldpp_dout(dpp, 0)<<"Listbuckettable failed " << dendl;
 
-  dbout(cct, 20)<<"ListbucketTable suceeded " << dbendl;
+  ldpp_dout(dpp, 20)<<"ListbucketTable suceeded " << dendl;
 
   return ret;
 }
 
-int SQLiteDB::ListAllObjects(DBOpParams *params)
+int SQLiteDB::ListAllObjects(const DoutPrefixProvider *dpp, DBOpParams *params)
 {
   int ret = -1;
   string schema;
@@ -730,12 +730,12 @@ int SQLiteDB::ListAllObjects(DBOpParams *params)
   map<string, class ObjectOp*> objectmap;
   string bucket;
 
-  //cout<<"########### Listing all Objects #############" << dbendl;
+  //cout<<"########### Listing all Objects #############" << dendl;
 
   objectmap = getObjectMap();
 
   if (objectmap.empty())
-    dbout(cct, 20)<<"objectmap empty " << dbendl;
+    ldpp_dout(dpp, 20)<<"objectmap empty " << dendl;
 
   for (iter = objectmap.begin(); iter != objectmap.end(); ++iter) {
     bucket = iter->first;
@@ -743,17 +743,17 @@ int SQLiteDB::ListAllObjects(DBOpParams *params)
       ".object.table";
     schema = ListTableSchema(params->object_table);
 
-    ret = exec(schema.c_str(), &list_callback);
+    ret = exec(dpp, schema.c_str(), &list_callback);
     if (ret)
-      dbout(cct, 0)<<"ListObjecttable failed " << dbendl;
+      ldpp_dout(dpp, 0)<<"ListObjecttable failed " << dendl;
 
-    dbout(cct, 20)<<"ListObjectTable suceeded " << dbendl;
+    ldpp_dout(dpp, 20)<<"ListObjectTable suceeded " << dendl;
   }
 
   return ret;
 }
 
-int SQLObjectOp::InitializeObjectOps()
+int SQLObjectOp::InitializeObjectOps(const DoutPrefixProvider *dpp)
 {
   InsertObject = new SQLInsertObject(sdb, cct);
   RemoveObject = new SQLRemoveObject(sdb, cct);
@@ -765,7 +765,7 @@ int SQLObjectOp::InitializeObjectOps()
   return 0;
 }
 
-int SQLObjectOp::FreeObjectOps()
+int SQLObjectOp::FreeObjectOps(const DoutPrefixProvider *dpp)
 {
   delete InsertObject;
   delete RemoveObject;
@@ -777,43 +777,43 @@ int SQLObjectOp::FreeObjectOps()
   return 0;
 }
 
-int SQLInsertUser::Prepare(struct DBOpParams *params)
+int SQLInsertUser::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLInsertUser - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLInsertUser - no db" << dendl;
     goto out;
   }
 
   p_params.user_table = params->user_table;
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareInsertUser");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareInsertUser");
 out:
   return ret;
 }
 
-int SQLInsertUser::Bind(struct DBOpParams *params)
+int SQLInsertUser::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.tenant.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.tenant.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.tenant.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.user_id.tenant.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_id.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.ns.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.ns.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.ns.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.user_id.ns.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.display_name.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.display_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.display_name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.display_name.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_email.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_email.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_email.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.user_email.c_str(), sdb);
 
   if (!params->op.user.uinfo.access_keys.empty()) {
     string access_key;
@@ -824,135 +824,135 @@ int SQLInsertUser::Bind(struct DBOpParams *params)
     access_key = k.id;
     key = k.key;
 
-    SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.access_keys_id.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), stmt, index, access_key.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.access_keys_id.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, stmt, index, access_key.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.access_keys_secret.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), stmt, index, key.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.access_keys_secret.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, stmt, index, key.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.access_keys.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.access_keys, sdb);
+    SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.access_keys.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.access_keys, sdb);
   }
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.swift_keys.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.swift_keys, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.swift_keys.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.swift_keys, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.subusers.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.subusers, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.subusers.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.subusers, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.suspended.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.suspended, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.suspended.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.user.uinfo.suspended, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.max_buckets.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.max_buckets, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.max_buckets.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.user.uinfo.max_buckets, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.op_mask.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.op_mask, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.op_mask.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.user.uinfo.op_mask, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_caps.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.caps, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_caps.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.caps, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.admin.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.admin, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.admin.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.user.uinfo.admin, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.system.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.system, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.system.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.user.uinfo.system, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.placement_name.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.default_placement.name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.placement_name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.default_placement.name.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.placement_storage_class.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.default_placement.storage_class.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.placement_storage_class.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.default_placement.storage_class.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.placement_tags.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.placement_tags, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.placement_tags.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.placement_tags, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.bucket_quota.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.bucket_quota, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.bucket_quota.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.bucket_quota, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.temp_url_keys.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.temp_url_keys, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.temp_url_keys.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.temp_url_keys, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_quota.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.user_quota, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_quota.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.user_quota, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.type.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.type, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.type.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.user.uinfo.type, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.mfa_ids.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.mfa_ids, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.mfa_ids.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.uinfo.mfa_ids, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.assumed_role_arn.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.assumed_role_arn.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.assumed_role_arn.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.assumed_role_arn.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_attrs.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.user_attrs, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_attrs.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.user.user_attrs, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_ver.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.user.user_version.ver, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_ver.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.user.user_version.ver, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_ver_tag.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.user_version.tag.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_ver_tag.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.user_version.tag.c_str(), sdb);
 
 out:
   return rc;
 }
 
-int SQLInsertUser::Execute(struct DBOpParams *params)
+int SQLInsertUser::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, NULL);
+  SQL_EXECUTE(dpp, params, stmt, NULL);
 out:
   return ret;
 }
 
-int SQLRemoveUser::Prepare(struct DBOpParams *params)
+int SQLRemoveUser::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLRemoveUser - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLRemoveUser - no db" << dendl;
     goto out;
   }
 
   p_params.user_table = params->user_table;
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareRemoveUser");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareRemoveUser");
 out:
   return ret;
 }
 
-int SQLRemoveUser::Bind(struct DBOpParams *params)
+int SQLRemoveUser::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_id.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
 
 out:
   return rc;
 }
 
-int SQLRemoveUser::Execute(struct DBOpParams *params)
+int SQLRemoveUser::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, NULL);
+  SQL_EXECUTE(dpp, params, stmt, NULL);
 out:
   return ret;
 }
 
-int SQLGetUser::Prepare(struct DBOpParams *params)
+int SQLGetUser::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLGetUser - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLGetUser - no db" << dendl;
     goto out;
   }
 
@@ -960,27 +960,27 @@ int SQLGetUser::Prepare(struct DBOpParams *params)
   p_params.op.query_str = params->op.query_str;
 
   if (params->op.query_str == "email") { 
-    SQL_PREPARE(ctx(), p_params, sdb, email_stmt, ret, "PrepareGetUser");
+    SQL_PREPARE(dpp, p_params, sdb, email_stmt, ret, "PrepareGetUser");
   } else if (params->op.query_str == "access_key") { 
-    SQL_PREPARE(ctx(), p_params, sdb, ak_stmt, ret, "PrepareGetUser");
+    SQL_PREPARE(dpp, p_params, sdb, ak_stmt, ret, "PrepareGetUser");
   } else if (params->op.query_str == "user_id") { 
-    SQL_PREPARE(ctx(), p_params, sdb, userid_stmt, ret, "PrepareGetUser");
+    SQL_PREPARE(dpp, p_params, sdb, userid_stmt, ret, "PrepareGetUser");
   } else { // by default by userid
-    SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareGetUser");
+    SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareGetUser");
   }
 out:
   return ret;
 }
 
-int SQLGetUser::Bind(struct DBOpParams *params)
+int SQLGetUser::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (params->op.query_str == "email") { 
-    SQL_BIND_INDEX(ctx(), email_stmt, index, p_params.op.user.user_email.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), email_stmt, index, params->op.user.uinfo.user_email.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, email_stmt, index, p_params.op.user.user_email.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, email_stmt, index, params->op.user.uinfo.user_email.c_str(), sdb);
   } else if (params->op.query_str == "access_key") { 
     if (!params->op.user.uinfo.access_keys.empty()) {
       string access_key;
@@ -989,158 +989,158 @@ int SQLGetUser::Bind(struct DBOpParams *params)
       const RGWAccessKey& k = it->second;
       access_key = k.id;
 
-      SQL_BIND_INDEX(ctx(), ak_stmt, index, p_params.op.user.access_keys_id.c_str(), sdb);
-      SQL_BIND_TEXT(ctx(), ak_stmt, index, access_key.c_str(), sdb);
+      SQL_BIND_INDEX(dpp, ak_stmt, index, p_params.op.user.access_keys_id.c_str(), sdb);
+      SQL_BIND_TEXT(dpp, ak_stmt, index, access_key.c_str(), sdb);
     }
   } else if (params->op.query_str == "user_id") { 
-    SQL_BIND_INDEX(ctx(), userid_stmt, index, p_params.op.user.tenant.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), userid_stmt, index, params->op.user.uinfo.user_id.tenant.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, userid_stmt, index, p_params.op.user.tenant.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, userid_stmt, index, params->op.user.uinfo.user_id.tenant.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), userid_stmt, index, p_params.op.user.user_id.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), userid_stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, userid_stmt, index, p_params.op.user.user_id.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, userid_stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), userid_stmt, index, p_params.op.user.ns.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), userid_stmt, index, params->op.user.uinfo.user_id.ns.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, userid_stmt, index, p_params.op.user.ns.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, userid_stmt, index, params->op.user.uinfo.user_id.ns.c_str(), sdb);
   } else { // by default by userid
-    SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_id.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
   }
 
 out:
   return rc;
 }
 
-int SQLGetUser::Execute(struct DBOpParams *params)
+int SQLGetUser::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
   if (params->op.query_str == "email") { 
-    SQL_EXECUTE(params, email_stmt, list_user);
+    SQL_EXECUTE(dpp, params, email_stmt, list_user);
   } else if (params->op.query_str == "access_key") { 
-    SQL_EXECUTE(params, ak_stmt, list_user);
+    SQL_EXECUTE(dpp, params, ak_stmt, list_user);
   } else if (params->op.query_str == "user_id") { 
-    SQL_EXECUTE(params, userid_stmt, list_user);
+    SQL_EXECUTE(dpp, params, userid_stmt, list_user);
   } else { // by default by userid
-    SQL_EXECUTE(params, stmt, list_user);
+    SQL_EXECUTE(dpp, params, stmt, list_user);
   }
 
 out:
   return ret;
 }
 
-int SQLInsertBucket::Prepare(struct DBOpParams *params)
+int SQLInsertBucket::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLInsertBucket - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLInsertBucket - no db" << dendl;
     goto out;
   }
 
   p_params.bucket_table = params->bucket_table;
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareInsertBucket");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareInsertBucket");
 
 out:
   return ret;
 }
 
-int SQLInsertBucket::Bind(struct DBOpParams *params)
+int SQLInsertBucket::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_id.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.tenant.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.tenant.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.tenant.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.tenant.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.marker.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.marker.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.marker.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.marker.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_id.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.bucket_id.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_id.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.bucket_id.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.size.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.ent.size, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.size.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.ent.size, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.size_rounded.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.ent.size_rounded, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.size_rounded.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.ent.size_rounded, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.creation_time.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.creation_time, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.creation_time.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.bucket.info.creation_time, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.count.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.ent.count, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.count.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.ent.count, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.placement_name.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.placement_rule.name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.placement_name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.placement_rule.name.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.placement_storage_class.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.placement_rule.storage_class.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.placement_storage_class.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.placement_rule.storage_class.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.flags.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.flags, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.flags.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.info.flags, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.zonegroup.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.zonegroup.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.zonegroup.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.zonegroup.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.has_instance_obj.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.has_instance_obj, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.has_instance_obj.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.info.has_instance_obj, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.quota.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.quota, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.quota.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.bucket.info.quota, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.requester_pays.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.requester_pays, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.requester_pays.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.info.requester_pays, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.has_website.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.has_website, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.has_website.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.info.has_website, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.website_conf.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.website_conf, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.website_conf.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.bucket.info.website_conf, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.swift_versioning.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.swift_versioning, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.swift_versioning.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.info.swift_versioning, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.swift_ver_location.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.swift_ver_location.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.swift_ver_location.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.swift_ver_location.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.mdsearch_config.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.mdsearch_config, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.mdsearch_config.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.bucket.info.mdsearch_config, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.new_bucket_instance_id.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.new_bucket_instance_id.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.new_bucket_instance_id.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.new_bucket_instance_id.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.obj_lock.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.obj_lock, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.obj_lock.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.bucket.info.obj_lock, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.sync_policy_info_groups.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.sync_policy, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.sync_policy_info_groups.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.bucket.info.sync_policy, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_attrs.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.bucket_attrs, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_attrs.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.bucket.bucket_attrs, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_ver.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.bucket_version.ver, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_ver.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.bucket.bucket_version.ver, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_ver_tag.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.bucket_version.tag.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_ver_tag.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.bucket_version.tag.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.mtime.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.mtime, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.mtime.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.bucket.mtime, sdb);
 
 out:
   return rc;
 }
 
-int SQLInsertBucket::Execute(struct DBOpParams *params)
+int SQLInsertBucket::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   class SQLObjectOp *ObPtr = NULL;
@@ -1148,24 +1148,24 @@ int SQLInsertBucket::Execute(struct DBOpParams *params)
 
   ObPtr = new SQLObjectOp(sdb, ctx());
 
-  objectmapInsert(bucket_name, ObPtr);
+  objectmapInsert(dpp, bucket_name, ObPtr);
 
   params->object_table = bucket_name + ".object.table";
 
-  (void)createObjectTable(params);
+  (void)createObjectTable(dpp, params);
 
-  SQL_EXECUTE(params, stmt, NULL);
+  SQL_EXECUTE(dpp, params, stmt, NULL);
 out:
   return ret;
 }
 
-int SQLUpdateBucket::Prepare(struct DBOpParams *params)
+int SQLUpdateBucket::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLUpdateBucket - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLUpdateBucket - no db" << dendl;
     goto out;
   }
 
@@ -1173,14 +1173,14 @@ int SQLUpdateBucket::Prepare(struct DBOpParams *params)
   p_params.bucket_table = params->bucket_table;
 
   if (params->op.query_str == "attrs") { 
-    SQL_PREPARE(ctx(), p_params, sdb, attrs_stmt, ret, "PrepareUpdateBucket");
+    SQL_PREPARE(dpp, p_params, sdb, attrs_stmt, ret, "PrepareUpdateBucket");
   } else if (params->op.query_str == "owner") { 
-    SQL_PREPARE(ctx(), p_params, sdb, owner_stmt, ret, "PrepareUpdateBucket");
+    SQL_PREPARE(dpp, p_params, sdb, owner_stmt, ret, "PrepareUpdateBucket");
   } else if (params->op.query_str == "info") { 
-    SQL_PREPARE(ctx(), p_params, sdb, info_stmt, ret, "PrepareUpdateBucket");
+    SQL_PREPARE(dpp, p_params, sdb, info_stmt, ret, "PrepareUpdateBucket");
   } else {
-    dbout(cct, 0)<<"In SQLUpdateBucket invalid query_str:" <<
-      params->op.query_str << "" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLUpdateBucket invalid query_str:" <<
+      params->op.query_str << "" << dendl;
     goto out;
   }
 
@@ -1188,7 +1188,7 @@ out:
   return ret;
 }
 
-int SQLUpdateBucket::Bind(struct DBOpParams *params)
+int SQLUpdateBucket::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
@@ -1203,96 +1203,96 @@ int SQLUpdateBucket::Bind(struct DBOpParams *params)
   } else if (params->op.query_str == "info") { 
     stmt = &info_stmt;
   } else {
-    dbout(cct, 0)<<"In SQLUpdateBucket invalid query_str:" <<
-      params->op.query_str << "" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLUpdateBucket invalid query_str:" <<
+      params->op.query_str << "" << dendl;
     goto out;
   }
 
   if (params->op.query_str == "attrs") { 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.bucket_attrs.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.bucket_attrs, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.bucket_attrs.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.bucket_attrs, sdb);
   } else if (params->op.query_str == "owner") { 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.creation_time.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.creation_time, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.creation_time.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.info.creation_time, sdb);
   } else if (params->op.query_str == "info") { 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.tenant.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.bucket.tenant.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.tenant.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.bucket.tenant.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.marker.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.bucket.marker.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.marker.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.bucket.marker.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.bucket_id.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.bucket.bucket_id.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.bucket_id.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.bucket.bucket_id.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.creation_time.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.creation_time, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.creation_time.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.info.creation_time, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.count.c_str(), sdb);
-    SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.ent.count, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.count.c_str(), sdb);
+    SQL_BIND_INT(dpp, *stmt, index, params->op.bucket.ent.count, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.placement_name.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.placement_rule.name.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.placement_name.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.placement_rule.name.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.placement_storage_class.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.placement_rule.storage_class.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.placement_storage_class.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.placement_rule.storage_class.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.flags.c_str(), sdb);
-    SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.flags, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.flags.c_str(), sdb);
+    SQL_BIND_INT(dpp, *stmt, index, params->op.bucket.info.flags, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.zonegroup.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.zonegroup.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.zonegroup.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.zonegroup.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.has_instance_obj.c_str(), sdb);
-    SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.has_instance_obj, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.has_instance_obj.c_str(), sdb);
+    SQL_BIND_INT(dpp, *stmt, index, params->op.bucket.info.has_instance_obj, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.quota.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.quota, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.quota.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.info.quota, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.requester_pays.c_str(), sdb);
-    SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.requester_pays, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.requester_pays.c_str(), sdb);
+    SQL_BIND_INT(dpp, *stmt, index, params->op.bucket.info.requester_pays, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.has_website.c_str(), sdb);
-    SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.has_website, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.has_website.c_str(), sdb);
+    SQL_BIND_INT(dpp, *stmt, index, params->op.bucket.info.has_website, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.website_conf.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.website_conf, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.website_conf.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.info.website_conf, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.swift_versioning.c_str(), sdb);
-    SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.swift_versioning, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.swift_versioning.c_str(), sdb);
+    SQL_BIND_INT(dpp, *stmt, index, params->op.bucket.info.swift_versioning, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.swift_ver_location.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.swift_ver_location.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.swift_ver_location.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.swift_ver_location.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.mdsearch_config.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.mdsearch_config, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.mdsearch_config.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.info.mdsearch_config, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.new_bucket_instance_id.c_str(), sdb);
-    SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.new_bucket_instance_id.c_str(), sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.new_bucket_instance_id.c_str(), sdb);
+    SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.new_bucket_instance_id.c_str(), sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.obj_lock.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.obj_lock, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.obj_lock.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.info.obj_lock, sdb);
 
-    SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.sync_policy_info_groups.c_str(), sdb);
-    SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.sync_policy, sdb);
+    SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.sync_policy_info_groups.c_str(), sdb);
+    SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.info.sync_policy, sdb);
   }
 
-  SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.user.user_id.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), *stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.user.user_id.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, *stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, *stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.bucket_ver.c_str(), sdb);
-  SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.bucket_version.ver, sdb);
+  SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.bucket_ver.c_str(), sdb);
+  SQL_BIND_INT(dpp, *stmt, index, params->op.bucket.bucket_version.ver, sdb);
 
-  SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.mtime.c_str(), sdb);
-  SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.mtime, sdb);
+  SQL_BIND_INDEX(dpp, *stmt, index, p_params.op.bucket.mtime.c_str(), sdb);
+  SQL_ENCODE_BLOB_PARAM(dpp, *stmt, index, params->op.bucket.mtime, sdb);
 
 out:
   return rc;
 }
 
-int SQLUpdateBucket::Execute(struct DBOpParams *params)
+int SQLUpdateBucket::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   sqlite3_stmt** stmt = NULL; // Prepared statement
@@ -1304,149 +1304,149 @@ int SQLUpdateBucket::Execute(struct DBOpParams *params)
   } else if (params->op.query_str == "info") { 
     stmt = &info_stmt;
   } else {
-    dbout(cct, 0)<<"In SQLUpdateBucket invalid query_str:" <<
-      params->op.query_str << "" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLUpdateBucket invalid query_str:" <<
+      params->op.query_str << "" << dendl;
     goto out;
   }
 
-  SQL_EXECUTE(params, *stmt, NULL);
+  SQL_EXECUTE(dpp, params, *stmt, NULL);
 out:
   return ret;
 }
 
-int SQLRemoveBucket::Prepare(struct DBOpParams *params)
+int SQLRemoveBucket::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLRemoveBucket - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLRemoveBucket - no db" << dendl;
     goto out;
   }
 
   p_params.bucket_table = params->bucket_table;
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareRemoveBucket");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareRemoveBucket");
 
 out:
   return ret;
 }
 
-int SQLRemoveBucket::Bind(struct DBOpParams *params)
+int SQLRemoveBucket::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 
 out:
   return rc;
 }
 
-int SQLRemoveBucket::Execute(struct DBOpParams *params)
+int SQLRemoveBucket::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  objectmapDelete(params->op.bucket.info.bucket.name);
+  objectmapDelete(dpp, params->op.bucket.info.bucket.name);
 
-  SQL_EXECUTE(params, stmt, NULL);
+  SQL_EXECUTE(dpp, params, stmt, NULL);
 out:
   return ret;
 }
 
-int SQLGetBucket::Prepare(struct DBOpParams *params)
+int SQLGetBucket::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLGetBucket - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLGetBucket - no db" << dendl;
     goto out;
   }
 
   p_params.bucket_table = params->bucket_table;
   p_params.user_table = params->user_table;
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareGetBucket");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareGetBucket");
 
 out:
   return ret;
 }
 
-int SQLGetBucket::Bind(struct DBOpParams *params)
+int SQLGetBucket::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 
 out:
   return rc;
 }
 
-int SQLGetBucket::Execute(struct DBOpParams *params)
+int SQLGetBucket::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
   params->op.name = "GetBucket";
-  SQL_EXECUTE(params, stmt, list_bucket);
+  SQL_EXECUTE(dpp, params, stmt, list_bucket);
 out:
   return ret;
 }
 
-int SQLListUserBuckets::Prepare(struct DBOpParams *params)
+int SQLListUserBuckets::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLListUserBuckets - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLListUserBuckets - no db" << dendl;
     goto out;
   }
 
   p_params.bucket_table = params->bucket_table;
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareListUserBuckets");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareListUserBuckets");
 
 out:
   return ret;
 }
 
-int SQLListUserBuckets::Bind(struct DBOpParams *params)
+int SQLListUserBuckets::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.user.user_id.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.min_marker.c_str(), sdb);
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.min_marker.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.min_marker.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.min_marker.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.list_max_count.c_str(), sdb);
-  SQL_BIND_INT(ctx(), stmt, index, params->op.list_max_count, sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.list_max_count.c_str(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->op.list_max_count, sdb);
 
 out:
   return rc;
 }
 
-int SQLListUserBuckets::Execute(struct DBOpParams *params)
+int SQLListUserBuckets::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, list_bucket);
+  SQL_EXECUTE(dpp, params, stmt, list_bucket);
 out:
   return ret;
 }
 
-int SQLInsertObject::Prepare(struct DBOpParams *params)
+int SQLInsertObject::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
@@ -1454,47 +1454,47 @@ int SQLInsertObject::Prepare(struct DBOpParams *params)
   string bucket_name;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLInsertObject - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLInsertObject - no db" << dendl;
     goto out;
   }
 
   bucket_name = params->op.bucket.info.bucket.name;
   p_params.object_table = bucket_name + ".object.table";
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareInsertObject");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareInsertObject");
 
 out:
   return ret;
 }
 
-int SQLInsertObject::Bind(struct DBOpParams *params)
+int SQLInsertObject::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.object.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->object.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 
 out:
   return rc;
 }
 
-int SQLInsertObject::Execute(struct DBOpParams *params)
+int SQLInsertObject::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, NULL);
+  SQL_EXECUTE(dpp, params, stmt, NULL);
 out:
   return ret;
 }
 
-int SQLRemoveObject::Prepare(struct DBOpParams *params)
+int SQLRemoveObject::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
@@ -1502,7 +1502,7 @@ int SQLRemoveObject::Prepare(struct DBOpParams *params)
   string bucket_name;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLRemoveObject - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLRemoveObject - no db" << dendl;
     goto out;
   }
 
@@ -1510,42 +1510,42 @@ int SQLRemoveObject::Prepare(struct DBOpParams *params)
   p_params.object_table = bucket_name + ".object.table";
   copy.object_table = bucket_name + ".object.table";
 
-  (void)createObjectTable(&copy);
+  (void)createObjectTable(dpp, &copy);
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareRemoveObject");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareRemoveObject");
 
 out:
   return ret;
 }
 
-int SQLRemoveObject::Bind(struct DBOpParams *params)
+int SQLRemoveObject::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.object.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->object.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 
 out:
   return rc;
 }
 
-int SQLRemoveObject::Execute(struct DBOpParams *params)
+int SQLRemoveObject::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, NULL);
+  SQL_EXECUTE(dpp, params, stmt, NULL);
 out:
   return ret;
 }
 
-int SQLListObject::Prepare(struct DBOpParams *params)
+int SQLListObject::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
@@ -1553,7 +1553,7 @@ int SQLListObject::Prepare(struct DBOpParams *params)
   string bucket_name;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLListObject - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLListObject - no db" << dendl;
     goto out;
   }
 
@@ -1561,43 +1561,43 @@ int SQLListObject::Prepare(struct DBOpParams *params)
   p_params.object_table = bucket_name + ".object.table";
   copy.object_table = bucket_name + ".object.table";
 
-  (void)createObjectTable(&copy);
+  (void)createObjectTable(dpp, &copy);
 
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareListObject");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareListObject");
 
 out:
   return ret;
 }
 
-int SQLListObject::Bind(struct DBOpParams *params)
+int SQLListObject::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.object.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->object.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 
 out:
   return rc;
 }
 
-int SQLListObject::Execute(struct DBOpParams *params)
+int SQLListObject::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, list_object);
+  SQL_EXECUTE(dpp, params, stmt, list_object);
 out:
   return ret;
 }
 
-int SQLPutObjectData::Prepare(struct DBOpParams *params)
+int SQLPutObjectData::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
@@ -1605,7 +1605,7 @@ int SQLPutObjectData::Prepare(struct DBOpParams *params)
   string bucket_name;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLPutObjectData - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLPutObjectData - no db" << dendl;
     goto out;
   }
 
@@ -1615,54 +1615,54 @@ int SQLPutObjectData::Prepare(struct DBOpParams *params)
   copy.object_table = bucket_name + ".object.table";
   copy.objectdata_table = bucket_name + ".objectdata.table";
 
-  (void)createObjectDataTable(&copy);
+  (void)createObjectDataTable(dpp, &copy);
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PreparePutObjectData");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PreparePutObjectData");
 
 out:
   return ret;
 }
 
-int SQLPutObjectData::Bind(struct DBOpParams *params)
+int SQLPutObjectData::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.object.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->object.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.offset.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.offset.c_str(), sdb);
 
-  SQL_BIND_INT(ctx(), stmt, 3, params->offset, sdb);
+  SQL_BIND_INT(dpp, stmt, 3, params->offset, sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.data.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.data.c_str(), sdb);
 
-  SQL_BIND_BLOB(ctx(), stmt, index, params->data.c_str(), params->data.length(), sdb);
+  SQL_BIND_BLOB(dpp, stmt, index, params->data.c_str(), params->data.length(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.datalen.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.datalen.c_str(), sdb);
 
-  SQL_BIND_INT(ctx(), stmt, index, params->data.length(), sdb);
+  SQL_BIND_INT(dpp, stmt, index, params->data.length(), sdb);
 
 out:
   return rc;
 }
 
-int SQLPutObjectData::Execute(struct DBOpParams *params)
+int SQLPutObjectData::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, NULL);
+  SQL_EXECUTE(dpp, params, stmt, NULL);
 out:
   return ret;
 }
 
-int SQLGetObjectData::Prepare(struct DBOpParams *params)
+int SQLGetObjectData::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
@@ -1670,7 +1670,7 @@ int SQLGetObjectData::Prepare(struct DBOpParams *params)
   string bucket_name;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLGetObjectData - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLGetObjectData - no db" << dendl;
     goto out;
   }
 
@@ -1680,41 +1680,41 @@ int SQLGetObjectData::Prepare(struct DBOpParams *params)
   copy.object_table = bucket_name + ".object.table";
   copy.objectdata_table = bucket_name + ".objectdata.table";
 
-  (void)createObjectDataTable(&copy);
+  (void)createObjectDataTable(dpp, &copy);
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareGetObjectData");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareGetObjectData");
 
 out:
   return ret;
 }
 
-int SQLGetObjectData::Bind(struct DBOpParams *params)
+int SQLGetObjectData::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.object.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->object.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 out:
   return rc;
 }
 
-int SQLGetObjectData::Execute(struct DBOpParams *params)
+int SQLGetObjectData::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, get_objectdata);
+  SQL_EXECUTE(dpp, params, stmt, get_objectdata);
 out:
   return ret;
 }
 
-int SQLDeleteObjectData::Prepare(struct DBOpParams *params)
+int SQLDeleteObjectData::Prepare(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
   struct DBOpPrepareParams p_params = PrepareParams;
@@ -1722,7 +1722,7 @@ int SQLDeleteObjectData::Prepare(struct DBOpParams *params)
   string bucket_name;
 
   if (!*sdb) {
-    dbout(cct, 0)<<"In SQLDeleteObjectData - no db" << dbendl;
+    ldpp_dout(dpp, 0)<<"In SQLDeleteObjectData - no db" << dendl;
     goto out;
   }
 
@@ -1732,36 +1732,36 @@ int SQLDeleteObjectData::Prepare(struct DBOpParams *params)
   copy.object_table = bucket_name + ".object.table";
   copy.objectdata_table = bucket_name + ".objectdata.table";
 
-  (void)createObjectDataTable(&copy);
+  (void)createObjectDataTable(dpp, &copy);
 
-  SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareDeleteObjectData");
+  SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareDeleteObjectData");
 
 out:
   return ret;
 }
 
-int SQLDeleteObjectData::Bind(struct DBOpParams *params)
+int SQLDeleteObjectData::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int index = -1;
   int rc = 0;
   struct DBOpPrepareParams p_params = PrepareParams;
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.object.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->object.c_str(), sdb);
 
-  SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
+  SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
 
-  SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
+  SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
 out:
   return rc;
 }
 
-int SQLDeleteObjectData::Execute(struct DBOpParams *params)
+int SQLDeleteObjectData::Execute(const DoutPrefixProvider *dpp, struct DBOpParams *params)
 {
   int ret = -1;
 
-  SQL_EXECUTE(params, stmt, NULL);
+  SQL_EXECUTE(dpp, params, stmt, NULL);
 out:
   return ret;
 }
diff --git a/src/rgw/store/dbstore/sqlite/sqliteDB.h b/src/rgw/store/dbstore/sqlite/sqliteDB.h
index 828595ce0b4..27d6523723e 100644
--- a/src/rgw/store/dbstore/sqlite/sqliteDB.h
+++ b/src/rgw/store/dbstore/sqlite/sqliteDB.h
@@ -23,44 +23,44 @@ class SQLiteDB : public DBStore, public DBOp{
     sqlite3_stmt *stmt = NULL;
     DBOpPrepareParams PrepareParams;
 
-    SQLiteDB(string db_name, CephContext *_cct) : DBStore(db_name, _cct) {
-      cct = _cct;
-      InitPrepareParams(PrepareParams);
+    SQLiteDB(string db_name, CephContext *_cct) : DBStore(db_name, _cct), cct(_cct) {
+      InitPrepareParams(get_def_dpp(), PrepareParams);
     }
-    SQLiteDB(sqlite3 *dbi, CephContext *_cct) : DBStore(_cct) {
+    SQLiteDB(sqlite3 *dbi, CephContext *_cct) : DBStore(_cct), cct(_cct) {
       db = (void*)dbi;
-      cct = _cct;
-      InitPrepareParams(PrepareParams);
+      InitPrepareParams(get_def_dpp(), PrepareParams);
     }
     ~SQLiteDB() {}
 
-    int exec(const char *schema,
+    void *openDB(const DoutPrefixProvider *dpp) override;
+    int closeDB(const DoutPrefixProvider *dpp) override;
+    int InitializeDBOps(const DoutPrefixProvider *dpp) override;
+    int FreeDBOps(const DoutPrefixProvider *dpp) override;
+
+    int InitPrepareParams(const DoutPrefixProvider *dpp, DBOpPrepareParams &params) override { return 0; }
+
+    int exec(const DoutPrefixProvider *dpp, const char *schema,
         int (*callback)(void*,int,char**,char**));
-    void *openDB();
-    int closeDB();
-    int Step(DBOpInfo &op, sqlite3_stmt *stmt,
-        int (*cbk)(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt));
-    int Reset(sqlite3_stmt *stmt);
-    int InitializeDBOps();
-    int FreeDBOps();
+    int Step(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *stmt,
+        int (*cbk)(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *stmt));
+    int Reset(const DoutPrefixProvider *dpp, sqlite3_stmt *stmt);
     /* default value matches with sqliteDB style */
-    int InitPrepareParams(DBOpPrepareParams &params) { return 0; }
-
-    int createTables();
-    int createBucketTable(DBOpParams *params);
-    int createUserTable(DBOpParams *params);
-    int createObjectTable(DBOpParams *params);
-    int createObjectDataTable(DBOpParams *params);
-    int createQuotaTable(DBOpParams *params);
-
-    int DeleteBucketTable(DBOpParams *params);
-    int DeleteUserTable(DBOpParams *params);
-    int DeleteObjectTable(DBOpParams *params);
-    int DeleteObjectDataTable(DBOpParams *params);
-
-    int ListAllBuckets(DBOpParams *params);
-    int ListAllUsers(DBOpParams *params);
-    int ListAllObjects(DBOpParams *params);
+
+    int createTables(const DoutPrefixProvider *dpp);
+    int createBucketTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int createUserTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int createObjectTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int createObjectDataTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int createQuotaTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+
+    int DeleteBucketTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int DeleteUserTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int DeleteObjectTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int DeleteObjectDataTable(const DoutPrefixProvider *dpp, DBOpParams *params);
+
+    int ListAllBuckets(const DoutPrefixProvider *dpp, DBOpParams *params) override;
+    int ListAllUsers(const DoutPrefixProvider *dpp, DBOpParams *params) override;
+    int ListAllObjects(const DoutPrefixProvider *dpp, DBOpParams *params) override;
 };
 
 class SQLObjectOp : public ObjectOp {
@@ -72,8 +72,8 @@ class SQLObjectOp : public ObjectOp {
     SQLObjectOp(sqlite3 **sdbi, CephContext *_cct) : sdb(sdbi), cct(_cct) {};
     ~SQLObjectOp() {}
 
-    int InitializeObjectOps();
-    int FreeObjectOps();
+    int InitializeObjectOps(const DoutPrefixProvider *dpp);
+    int FreeObjectOps(const DoutPrefixProvider *dpp);
 };
 
 class SQLInsertUser : public SQLiteDB, public InsertUserOp {
@@ -87,9 +87,9 @@ class SQLInsertUser : public SQLiteDB, public InsertUserOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLRemoveUser : public SQLiteDB, public RemoveUserOp {
@@ -103,9 +103,9 @@ class SQLRemoveUser : public SQLiteDB, public RemoveUserOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLGetUser : public SQLiteDB, public GetUserOp {
@@ -128,9 +128,9 @@ class SQLGetUser : public SQLiteDB, public GetUserOp {
       if (userid_stmt)
         sqlite3_finalize(userid_stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLInsertBucket : public SQLiteDB, public InsertBucketOp {
@@ -144,9 +144,9 @@ class SQLInsertBucket : public SQLiteDB, public InsertBucketOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLUpdateBucket : public SQLiteDB, public UpdateBucketOp {
@@ -166,9 +166,9 @@ class SQLUpdateBucket : public SQLiteDB, public UpdateBucketOp {
       if (owner_stmt)
         sqlite3_finalize(owner_stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLRemoveBucket : public SQLiteDB, public RemoveBucketOp {
@@ -182,9 +182,9 @@ class SQLRemoveBucket : public SQLiteDB, public RemoveBucketOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLGetBucket : public SQLiteDB, public GetBucketOp {
@@ -198,9 +198,9 @@ class SQLGetBucket : public SQLiteDB, public GetBucketOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLListUserBuckets : public SQLiteDB, public ListUserBucketsOp {
@@ -214,9 +214,9 @@ class SQLListUserBuckets : public SQLiteDB, public ListUserBucketsOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLInsertObject : public SQLiteDB, public InsertObjectOp {
@@ -232,9 +232,9 @@ class SQLInsertObject : public SQLiteDB, public InsertObjectOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLRemoveObject : public SQLiteDB, public RemoveObjectOp {
@@ -250,9 +250,9 @@ class SQLRemoveObject : public SQLiteDB, public RemoveObjectOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLListObject : public SQLiteDB, public ListObjectOp {
@@ -268,9 +268,9 @@ class SQLListObject : public SQLiteDB, public ListObjectOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLPutObjectData : public SQLiteDB, public PutObjectDataOp {
@@ -286,9 +286,9 @@ class SQLPutObjectData : public SQLiteDB, public PutObjectDataOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLGetObjectData : public SQLiteDB, public GetObjectDataOp {
@@ -304,9 +304,9 @@ class SQLGetObjectData : public SQLiteDB, public GetObjectDataOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 
 class SQLDeleteObjectData : public SQLiteDB, public DeleteObjectDataOp {
@@ -322,8 +322,8 @@ class SQLDeleteObjectData : public SQLiteDB, public DeleteObjectDataOp {
       if (stmt)
         sqlite3_finalize(stmt);
     }
-    int Prepare(DBOpParams *params);
-    int Execute(DBOpParams *params);
-    int Bind(DBOpParams *params);
+    int Prepare(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Execute(const DoutPrefixProvider *dpp, DBOpParams *params);
+    int Bind(const DoutPrefixProvider *dpp, DBOpParams *params);
 };
 #endif
diff --git a/src/rgw/store/dbstore/tests/dbstore_tests.cc b/src/rgw/store/dbstore/tests/dbstore_tests.cc
index 187d364fca0..1cb0657d912 100644
--- a/src/rgw/store/dbstore/tests/dbstore_tests.cc
+++ b/src/rgw/store/dbstore/tests/dbstore_tests.cc
@@ -12,8 +12,6 @@ using namespace std;
 
 vector<const char*> args;
 
-CephContext *cct;
-
 namespace gtest {
   class Environment* env;
 
@@ -30,7 +28,7 @@ namespace gtest {
 
       void SetUp() override {
         cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
-            CODE_ENVIRONMENT_UTILITY, 1)->get();
+            CODE_ENVIRONMENT_DAEMON, CINIT_FLAG_NO_MON_CONFIG, 1)->get();
         if (!db_type.compare("SQLite")) {
           db = new SQLiteDB(tenant, cct);
           ASSERT_TRUE(db != nullptr);
@@ -42,7 +40,7 @@ namespace gtest {
       void TearDown() override {
         if (!db)
           return;
-        db->Destroy();
+        db->Destroy(db->get_def_dpp());
         delete db;
       }
 
@@ -52,6 +50,7 @@ namespace gtest {
       int ret;
       string logfile = "rgw_dbstore_tests.log";
       int loglevel = 30;
+      CephContext *cct;
   };
 }
 
@@ -70,11 +69,14 @@ namespace {
       string object1 = "object1";
       string data = "Hello World";
       DBOpParams GlobalParams = {};
+      const DoutPrefixProvider *dpp;
 
       DBStoreBaseTest() {}
       void SetUp() {
         db = gtest::env->db;
         ASSERT_TRUE(db != nullptr);
+        dpp = db->get_def_dpp();
+        ASSERT_TRUE(dpp != nullptr);
 
         GlobalParams.op.user.uinfo.display_name = user1;
         GlobalParams.op.user.uinfo.user_id.id = user_id1;
@@ -88,7 +90,7 @@ namespace {
          * special based on fop. Hence its okay to do
          * global initialization once.
          */
-        ret = db->InitializeParams("", &GlobalParams);
+        ret = db->InitializeParams(dpp, "", &GlobalParams);
         ASSERT_EQ(ret, 0);
       }
 
@@ -114,7 +116,7 @@ TEST_F(DBStoreBaseTest, InsertUser) {
   params.op.user.user_version.ver = 1;    
   params.op.user.user_version.tag = "UserTAG";    
 
-  ret = db->ProcessOp("InsertUser", &params);
+  ret = db->ProcessOp(dpp, "InsertUser", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -122,7 +124,7 @@ TEST_F(DBStoreBaseTest, GetUser) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("GetUser", &params);
+  ret = db->ProcessOp(dpp, "GetUser", &params);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(params.op.user.uinfo.user_id.tenant, "tenant");
   ASSERT_EQ(params.op.user.uinfo.user_email, "user1@dbstore.com");
@@ -150,7 +152,7 @@ TEST_F(DBStoreBaseTest, GetUserQuery) {
   params.op.query_str = "email";
   params.op.user.uinfo.user_email = "user1@dbstore.com";
 
-  ret = db->ProcessOp("GetUser", &params);
+  ret = db->ProcessOp(dpp, "GetUser", &params);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(params.op.user.uinfo.user_id.tenant, "tenant");
   ASSERT_EQ(params.op.user.uinfo.user_email, "user1@dbstore.com");
@@ -178,7 +180,7 @@ TEST_F(DBStoreBaseTest, GetUserQueryByEmail) {
   map<std::string, bufferlist> attrs;
   RGWObjVersionTracker objv;
 
-  ret = db->get_user("email", email, uinfo, &attrs, &objv);
+  ret = db->get_user(dpp, "email", email, uinfo, &attrs, &objv);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(uinfo.user_id.tenant, "tenant");
   ASSERT_EQ(uinfo.user_email, "user1@dbstore.com");
@@ -204,7 +206,7 @@ TEST_F(DBStoreBaseTest, GetUserQueryByAccessKey) {
   RGWUserInfo uinfo;
   string key = "id1";
 
-  ret = db->get_user("access_key", key, uinfo, nullptr, nullptr);
+  ret = db->get_user(dpp, "access_key", key, uinfo, nullptr, nullptr);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(uinfo.user_id.tenant, "tenant");
   ASSERT_EQ(uinfo.user_email, "user1@dbstore.com");
@@ -250,7 +252,7 @@ TEST_F(DBStoreBaseTest, StoreUser) {
   uinfo.access_keys["id2"] = k2;
 
   /* non exclusive create..should create new one */
-  ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo);
+  ret = db->store_user(dpp, uinfo, true, &attrs, &objv_tracker, &old_uinfo);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(old_uinfo.user_email, "");
   ASSERT_EQ(objv_tracker.read_version.ver, 1);
@@ -258,7 +260,7 @@ TEST_F(DBStoreBaseTest, StoreUser) {
 
   /* invalid version number */
   objv_tracker.read_version.ver = 4;
-  ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo);
+  ret = db->store_user(dpp, uinfo, true, &attrs, &objv_tracker, &old_uinfo);
   ASSERT_EQ(ret, -125); /* returns ECANCELED */
   ASSERT_EQ(old_uinfo.user_id.id, uinfo.user_id.id);
   ASSERT_EQ(old_uinfo.user_email, uinfo.user_email);
@@ -266,12 +268,12 @@ TEST_F(DBStoreBaseTest, StoreUser) {
   /* exclusive create..should not create new one */
   uinfo.user_email = "user2_new@dbstore.com";
   objv_tracker.read_version.ver = 1;
-  ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo);
+  ret = db->store_user(dpp, uinfo, true, &attrs, &objv_tracker, &old_uinfo);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(old_uinfo.user_email, "user2@dbstore.com");
   ASSERT_EQ(objv_tracker.read_version.ver, 1);
 
-  ret = db->store_user(uinfo, false, &attrs, &objv_tracker, &old_uinfo);
+  ret = db->store_user(dpp, uinfo, false, &attrs, &objv_tracker, &old_uinfo);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(old_uinfo.user_email, "user2@dbstore.com");
   ASSERT_EQ(objv_tracker.read_version.ver, 2);
@@ -287,7 +289,7 @@ TEST_F(DBStoreBaseTest, GetUserQueryByUserID) {
   uinfo.user_id.tenant = "tenant";
   uinfo.user_id.id = "user_id2";
 
-  ret = db->get_user("user_id", "", uinfo, &attrs, &objv);
+  ret = db->get_user(dpp, "user_id", "", uinfo, &attrs, &objv);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(uinfo.user_id.tenant, "tenant");
   ASSERT_EQ(uinfo.user_email, "user2_new@dbstore.com");
@@ -324,7 +326,7 @@ TEST_F(DBStoreBaseTest, ListAllUsers) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ListAllUsers(&params);
+  ret = db->ListAllUsers(dpp, &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -344,7 +346,7 @@ TEST_F(DBStoreBaseTest, InsertBucket) {
 
   params.op.bucket.mtime = bucket_mtime;
 
-  ret = db->ProcessOp("InsertBucket", &params);
+  ret = db->ProcessOp(dpp, "InsertBucket", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -364,12 +366,12 @@ TEST_F(DBStoreBaseTest, UpdateBucketAttrs) {
 
   /* invalid version number */
   objv.read_version.ver = 4;
-  ret = db->update_bucket("attrs", info, false, nullptr, &attrs, &bucket_mtime, &objv);
+  ret = db->update_bucket(dpp, "attrs", info, false, nullptr, &attrs, &bucket_mtime, &objv);
   ASSERT_EQ(ret, -125); /* returns ECANCELED */
 
   /* right version number */
   objv.read_version.ver = 1;
-  ret = db->update_bucket("attrs", info, false, nullptr, &attrs, &bucket_mtime, &objv);
+  ret = db->update_bucket(dpp, "attrs", info, false, nullptr, &attrs, &bucket_mtime, &objv);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(objv.read_version.ver, 2);
 }
@@ -382,7 +384,7 @@ TEST_F(DBStoreBaseTest, BucketChown) {
 
   info.bucket.name = "bucket1";
 
-  ret = db->update_bucket("owner", info, false, &user, nullptr, &bucket_mtime, nullptr);
+  ret = db->update_bucket(dpp, "owner", info, false, &user, nullptr, &bucket_mtime, nullptr);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(info.objv_tracker.read_version.ver, 3);
 }
@@ -394,13 +396,13 @@ TEST_F(DBStoreBaseTest, UpdateBucketInfo) {
 
   params.op.bucket.info.bucket.name = "bucket1";
 
-  ret = db->ProcessOp("GetBucket", &params);
+  ret = db->ProcessOp(dpp, "GetBucket", &params);
   ASSERT_EQ(ret, 0);
 
   info = params.op.bucket.info;
 
   info.bucket.marker = "marker2";
-  ret = db->update_bucket("info", info, false, nullptr, nullptr, &bucket_mtime, nullptr);
+  ret = db->update_bucket(dpp, "info", info, false, nullptr, nullptr, &bucket_mtime, nullptr);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(info.objv_tracker.read_version.ver, 4);
 }
@@ -409,7 +411,7 @@ TEST_F(DBStoreBaseTest, GetBucket) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("GetBucket", &params);
+  ret = db->ProcessOp(dpp, "GetBucket", &params);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(params.op.bucket.info.bucket.name, "bucket1");
   ASSERT_EQ(params.op.bucket.info.bucket.tenant, "tenant");
@@ -440,7 +442,7 @@ TEST_F(DBStoreBaseTest, RemoveBucketAPI) {
 
   info.bucket.name = "bucket1";
 
-  ret = db->remove_bucket(info);
+  ret = db->remove_bucket(dpp, info);
   ASSERT_EQ(ret, 0);
 }
 
@@ -454,12 +456,12 @@ TEST_F(DBStoreBaseTest, RemoveUserAPI) {
 
   /* invalid version number...should fail */
   objv.read_version.ver = 4;
-  ret = db->remove_user(uinfo, &objv);
+  ret = db->remove_user(dpp, uinfo, &objv);
   ASSERT_EQ(ret, -125);
 
   /* invalid version number...should fail */
   objv.read_version.ver = 2;
-  ret = db->remove_user(uinfo, &objv);
+  ret = db->remove_user(dpp, uinfo, &objv);
   ASSERT_EQ(ret, 0);
 }
 
@@ -483,29 +485,29 @@ TEST_F(DBStoreBaseTest, CreateBucket) {
   rule.name = "rule1";
   rule.storage_class = "sc1";
 
-  ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL,
+  ret = db->create_bucket(dpp, owner, bucket, "zid", rule, "swift_ver", NULL,
       attrs, info, &objv, NULL, bucket_mtime, NULL, NULL,
-      null_yield, NULL, false);
+      null_yield, false);
   ASSERT_EQ(ret, 0);
   bucket.name = "bucket2";
-  ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL,
+  ret = db->create_bucket(dpp, owner, bucket, "zid", rule, "swift_ver", NULL,
       attrs, info, &objv, NULL, bucket_mtime, NULL, NULL,
-      null_yield, NULL, false);
+      null_yield, false);
   ASSERT_EQ(ret, 0);
   bucket.name = "bucket3";
-  ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL,
+  ret = db->create_bucket(dpp, owner, bucket, "zid", rule, "swift_ver", NULL,
       attrs, info, &objv, NULL, bucket_mtime, NULL, NULL,
-      null_yield, NULL, false);
+      null_yield, false);
   ASSERT_EQ(ret, 0);
   bucket.name = "bucket4";
-  ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL,
+  ret = db->create_bucket(dpp, owner, bucket, "zid", rule, "swift_ver", NULL,
       attrs, info, &objv, NULL, bucket_mtime, NULL, NULL,
-      null_yield, NULL, false);
+      null_yield, false);
   ASSERT_EQ(ret, 0);
   bucket.name = "bucket5";
-  ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL,
+  ret = db->create_bucket(dpp, owner, bucket, "zid", rule, "swift_ver", NULL,
       attrs, info, &objv, NULL, bucket_mtime, NULL, NULL,
-      null_yield, NULL, false);
+      null_yield, false);
   ASSERT_EQ(ret, 0);
 }
 
@@ -517,7 +519,7 @@ TEST_F(DBStoreBaseTest, GetBucketQueryByName) {
   ceph::real_time mtime;
   obj_version objv;
 
-  ret = db->get_bucket_info("name", "", binfo, &attrs, &mtime, &objv);
+  ret = db->get_bucket_info(dpp, "name", "", binfo, &attrs, &mtime, &objv);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(binfo.bucket.name, "bucket2");
   ASSERT_EQ(binfo.bucket.tenant, "tenant");
@@ -548,7 +550,7 @@ TEST_F(DBStoreBaseTest, ListUserBuckets) {
   marker1 = "";
   do {
     is_truncated = false;
-    ret = db->list_buckets(owner, marker1, "", max, need_stats, &ulist, &is_truncated);
+    ret = db->list_buckets(dpp, owner, marker1, "", max, need_stats, &ulist, &is_truncated);
     ASSERT_EQ(ret, 0);
 
     cout << "marker1 :" << marker1 << "\n";
@@ -574,7 +576,7 @@ TEST_F(DBStoreBaseTest, ListAllBuckets) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ListAllBuckets(&params);
+  ret = db->ListAllBuckets(dpp, &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -582,7 +584,7 @@ TEST_F(DBStoreBaseTest, InsertObject) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("InsertObject", &params);
+  ret = db->ProcessOp(dpp, "InsertObject", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -590,7 +592,7 @@ TEST_F(DBStoreBaseTest, ListObject) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("ListObject", &params);
+  ret = db->ProcessOp(dpp, "ListObject", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -598,7 +600,7 @@ TEST_F(DBStoreBaseTest, ListAllObjects) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ListAllObjects(&params);
+  ret = db->ListAllObjects(dpp, &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -606,7 +608,7 @@ TEST_F(DBStoreBaseTest, PutObjectData) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("PutObjectData", &params);
+  ret = db->ProcessOp(dpp, "PutObjectData", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -614,7 +616,7 @@ TEST_F(DBStoreBaseTest, GetObjectData) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("GetObjectData", &params);
+  ret = db->ProcessOp(dpp, "GetObjectData", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -622,7 +624,7 @@ TEST_F(DBStoreBaseTest, DeleteObjectData) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("DeleteObjectData", &params);
+  ret = db->ProcessOp(dpp, "DeleteObjectData", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -630,7 +632,7 @@ TEST_F(DBStoreBaseTest, RemoveObject) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("RemoveObject", &params);
+  ret = db->ProcessOp(dpp, "RemoveObject", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -638,7 +640,7 @@ TEST_F(DBStoreBaseTest, RemoveBucket) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("RemoveBucket", &params);
+  ret = db->ProcessOp(dpp, "RemoveBucket", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -646,7 +648,7 @@ TEST_F(DBStoreBaseTest, RemoveUser) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-  ret = db->ProcessOp("RemoveUser", &params);
+  ret = db->ProcessOp(dpp, "RemoveUser", &params);
   ASSERT_EQ(ret, 0);
 }
 
@@ -663,7 +665,7 @@ TEST_F(DBStoreBaseTest, InsertTestIDUser) {
   params.op.user.user_version.ver = 1;    
   params.op.user.user_version.tag = "UserTAG";    
 
-  ret = db->ProcessOp("InsertUser", &params);
+  ret = db->ProcessOp(dpp, "InsertUser", &params);
   ASSERT_EQ(ret, 0);
 }