Basic Jaeger Tracing Added

src/rgw/rgw_asio_frontend.cc

@@ -193,6 +193,7 @@ void handle_connection(boost::asio::io_context& context,
         std::string span_name;
         auto time = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
         span_name = std::ctime(&time);
+        span_name = "rgw_asio_frontend "+span_name;
         Span span=tracer.new_span(span_name.c_str());
         if(root_span == nullptr)
           root_span=tracer.new_span(span_name.c_str());

src/rgw/rgw_op.cc

@@ -2980,6 +2980,19 @@ int RGWListBuckets::verify_permission()
   return 0;
 }
 
+int RGWListBuckets::verify_permission(Jager_Tracer& tracer, const Span& parent_span)
+{
+  Span span = tracer.child_span("rgw_op.cc RGWListBuckets::verify_permission", parent_span);
+  rgw::Partition partition = rgw::Partition::aws;
+  rgw::Service service = rgw::Service::s3;
+
+  if (!verify_user_permission(this, s, ARN(partition, service, "", s->user->get_tenant(), "*"), rgw::IAM::s3ListAllMyBuckets)) {
+    return -EACCES;
+  }
+
+  return 0;
+}
+
 int RGWGetUsage::verify_permission()
 {
   if (s->auth.identity->is_anonymous()) {
@@ -2999,7 +3012,7 @@ void RGWListBuckets::execute(Jager_Tracer& tracer,const Span& parent_span)
 
   const uint64_t max_buckets = s->cct->_conf->rgw_list_buckets_max_chunk;
 
-  op_ret = get_params();
+  op_ret = get_params(tracer, span);
   if (op_ret < 0) {
     goto send_end;
   }
@@ -3023,7 +3036,7 @@ void RGWListBuckets::execute(Jager_Tracer& tracer,const Span& parent_span)
 
     rgw::sal::RGWRadosUser user(store, s->user->get_id());
 
-    op_ret = user.list_buckets(marker, end_marker, read_count, should_get_stats(), buckets);
+    op_ret = user.list_buckets(marker, end_marker, read_count, should_get_stats(), buckets, tracer, span);
 
     if (op_ret < 0) {
       /* hmm.. something wrong here.. the user was authenticated, so it
@@ -3072,7 +3085,7 @@ void RGWListBuckets::execute(Jager_Tracer& tracer,const Span& parent_span)
       map<string, rgw::sal::RGWBucket*>::reverse_iterator riter = m.rbegin();
       marker = riter->first;
 
-      handle_listing_chunk(std::move(buckets));
+      handle_listing_chunk(std::move(buckets), tracer, span);
     }
   } while (is_truncated && !done);
 
@@ -3664,7 +3677,7 @@ void RGWListBucket::execute(Jager_Tracer& tracer,const Span& parent_span)
   list_op.params.list_versions = list_versions;
   list_op.params.allow_unordered = allow_unordered;
 
-  op_ret = list_op.list_objects(max, &objs, &common_prefixes, &is_truncated, s->yield);
+  op_ret = list_op.list_objects(max, &objs, &common_prefixes, &is_truncated, tracer, span, s->yield);
   if (op_ret >= 0) {
     next_marker = list_op.get_next_marker();
   }

src/rgw/rgw_op.h

@@ -793,20 +793,30 @@ class RGWListBuckets : public RGWOp {
   }
 
   int verify_permission() override;
+  int verify_permission(Jager_Tracer&, const Span&) override;
 	void execute(Jager_Tracer&,const Span&) override;
   void execute() override;
 
   virtual int get_params() = 0;
+  virtual int get_params(Jager_Tracer&, const Span&) = 0;
   virtual void handle_listing_chunk(rgw::sal::RGWBucketList&& buckets) {
     /* The default implementation, used by e.g. S3, just generates a new
      * part of listing and sends it client immediately. Swift can behave
      * differently: when the reverse option is requested, all incoming
      * instances of RGWBucketList are buffered and finally reversed. */
     return send_response_data(buckets);
   }
+  virtual void handle_listing_chunk(rgw::sal::RGWBucketList&& buckets, Jager_Tracer& tracer, const Span& parent_span) {
+    /* The default implementation, used by e.g. S3, just generates a new
+     * part of listing and sends it client immediately. Swift can behave
+     * differently: when the reverse option is requested, all incoming
+     * instances of RGWBucketList are buffered and finally reversed. */
+    return send_response_data(buckets, tracer, parent_span);
+  }
   virtual void send_response_begin(bool has_buckets) = 0;
   virtual void send_response_begin(bool has_buckets, Jager_Tracer&, const Span&, Span&) = 0;
   virtual void send_response_data(rgw::sal::RGWBucketList& buckets) = 0;
+  virtual void send_response_data(rgw::sal::RGWBucketList& buckets, Jager_Tracer&, const Span&) = 0;
   virtual void send_response_end() = 0;
   virtual void send_response_end(Span, const Span&) = 0;
   void send_response() override {}

src/rgw/rgw_rados.cc

@@ -1998,6 +1998,21 @@ int RGWRados::Bucket::List::list_objects_ordered(
   return 0;
 } // list_objects_ordered
 
+int RGWRados::Bucket::List::list_objects_ordered(
+  int64_t max_p,
+  vector<rgw_bucket_dir_entry> *result,
+  map<string, bool> *common_prefixes,
+  bool *is_truncated, Jager_Tracer& tracer, const Span& parent_span,
+  optional_yield y)
+  {
+    Span span = tracer.child_span("rgw_rados RGWRados::Bucket::List::list_objects_ordered", parent_span);
+    return RGWRados::Bucket::List::list_objects_ordered(
+                                                max_p,
+                                                result,
+                                                common_prefixes,
+                                                is_truncated,
+                                                y);
+  }
 
 /**
  * Get listing of the objects in a bucket and allow the results to be out
@@ -2142,6 +2157,19 @@ int RGWRados::Bucket::List::list_objects_unordered(int64_t max_p,
   return 0;
 } // list_objects_unordered
 
+int RGWRados::Bucket::List::list_objects_unordered(int64_t max_p,
+						   vector<rgw_bucket_dir_entry> *result,
+						   map<string, bool> *common_prefixes,
+						   bool *is_truncated, Jager_Tracer& tracer, const Span& parent_span,
+                                                   optional_yield y)
+{
+  Span span = tracer.child_span("rgw_rados.cc RGWRados::Bucket::List::list_objects_unordered", parent_span);
+  return RGWRados::Bucket::List::list_objects_unordered(max_p,
+                                                        result,
+                                                        common_prefixes,
+                                                        is_truncated,
+                                                        y);
+}
 
 /**
  * create a rados pool, associated meta info
@@ -2275,6 +2303,37 @@ int RGWRados::create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
   return -ENOENT;
 }
 
+int RGWRados::create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
+                            const string& zonegroup_id,
+                            const rgw_placement_rule& placement_rule,
+                            const string& swift_ver_location,
+                            const RGWQuotaInfo * pquota_info,
+			    map<std::string, bufferlist>& attrs,
+                            RGWBucketInfo& info,
+                            obj_version *pobjv,
+                            obj_version *pep_objv,
+                            real_time creation_time,
+                            rgw_bucket *pmaster_bucket,
+                            uint32_t *pmaster_num_shards,
+                            Jager_Tracer& tracer, const Span& parent_span,
+			    bool exclusive)
+{
+  Span span = tracer.child_span("rgw_rados.cc RGWRados::create_bucket", parent_span);
+  return RGWRados::create_bucket(owner, bucket,
+                            zonegroup_id,
+                            placement_rule,
+                            swift_ver_location,
+                            pquota_info,
+			                       attrs,
+                            info,
+                            pobjv,
+                            pep_objv,
+                            creation_time,
+                            pmaster_bucket,
+                            pmaster_num_shards,
+			                      exclusive);
+}
+
 bool RGWRados::get_obj_data_pool(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_pool *pool)
 {
   return rgw_get_obj_data_pool(svc.zone->get_zonegroup(), svc.zone->get_zone_params(), placement_rule, obj, pool);

src/rgw/rgw_rados.h

@@ -672,6 +672,20 @@ class RGWRados
                             rgw_bucket *master_bucket,
                             uint32_t *master_num_shards,
                             bool exclusive = true);
+  int create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
+                            const string& zonegroup_id,
+                            const rgw_placement_rule& placement_rule,
+                            const string& swift_ver_location,
+                            const RGWQuotaInfo * pquota_info,
+                            map<std::string,bufferlist>& attrs,
+                            RGWBucketInfo& bucket_info,
+                            obj_version *pobjv,
+                            obj_version *pep_objv,
+                            ceph::real_time creation_time,
+                            rgw_bucket *master_bucket,
+                            uint32_t *master_num_shards,
+                            Jager_Tracer&, const Span&,
+                            bool exclusive = true);
 
   RGWCoroutinesManagerRegistry *get_cr_registry() { return cr_registry; }
 
@@ -1001,11 +1015,21 @@ class RGWRados
 			       map<string, bool> *common_prefixes,
 			       bool *is_truncated,
                                optional_yield y);
+      int list_objects_ordered(int64_t max,
+			       vector<rgw_bucket_dir_entry> *result,
+			       map<string, bool> *common_prefixes,
+			       bool *is_truncated, Jager_Tracer&, const Span&,
+                               optional_yield y);
       int list_objects_unordered(int64_t max,
 				 vector<rgw_bucket_dir_entry> *result,
 				 map<string, bool> *common_prefixes,
 				 bool *is_truncated,
                                  optional_yield y);
+      int list_objects_unordered(int64_t max,
+				 vector<rgw_bucket_dir_entry> *result,
+				 map<string, bool> *common_prefixes,
+				 bool *is_truncated, Jager_Tracer&, const Span&,
+                                 optional_yield y);
 
     public:
 
@@ -1043,6 +1067,20 @@ class RGWRados
 				      is_truncated, y);
 	}
       }
+
+  int list_objects(int64_t max,
+		       vector<rgw_bucket_dir_entry> *result,
+		       map<string, bool> *common_prefixes,
+		       bool *is_truncated,Jager_Tracer& tracer, const Span& parent_span,
+                       optional_yield y) {
+	if (params.allow_unordered) {
+	  return list_objects_unordered(max, result, common_prefixes,
+					is_truncated, tracer, parent_span, y);
+	} else {
+	  return list_objects_ordered(max, result, common_prefixes,
+				      is_truncated, tracer, parent_span, y);
+	}
+      }
       rgw_obj_key& get_next_marker() {
         return next_marker;
       }

src/rgw/rgw_rest_s3.cc

@@ -1207,7 +1207,7 @@ void RGWListBuckets_ObjStore_S3::send_response_begin(bool has_buckets)
 
 void RGWListBuckets_ObjStore_S3::send_response_begin(bool has_buckets, Jager_Tracer& tracer, const Span& parent_span, Span& span)
 {
-  span = tracer.child_span("rgw_rest_s3.cc RGWListBuckets_ObjStore_S3::send_response", parent_span);
+  span = tracer.child_span("rgw_rest_s3.cc RGWListBuckets_ObjStore_S3::send_response_begin", parent_span);
   RGWListBuckets_ObjStore_S3::send_response_begin(has_buckets);
 }
 
@@ -1226,6 +1226,12 @@ void RGWListBuckets_ObjStore_S3::send_response_data(rgw::sal::RGWBucketList& buc
   rgw_flush_formatter(s, s->formatter);
 }
 
+void RGWListBuckets_ObjStore_S3::send_response_data(rgw::sal::RGWBucketList& buckets, Jager_Tracer& tracer, const Span& parent_span)
+{
+  Span span = tracer.child_span("rgw_rest_s3.cc RGWListBuckets_ObjStore_S3::send_response_data", parent_span);
+  RGWListBuckets_ObjStore_S3::send_response_data(buckets);
+}
+
 void RGWListBuckets_ObjStore_S3::send_response_end()
 {
   if (sent_data) {
@@ -1239,6 +1245,7 @@ void RGWListBuckets_ObjStore_S3::send_response_end(Span span, const Span& parent
 {
   parent_span->SetTag("operation_gateway", "s3");
   RGWListBuckets_ObjStore_S3::send_response_end();
+  span->Finish();
 }
 
 int RGWGetUsage_ObjStore_S3::get_params()

src/rgw/rgw_rest_s3.h

@@ -133,9 +133,15 @@ class RGWListBuckets_ObjStore_S3 : public RGWListBuckets_ObjStore {
     limit = -1; /* no limit */
     return 0;
   }
+  int get_params(Jager_Tracer& tracer, const Span& parent_span) override {
+    Span span = tracer.child_span("rgw_rest_s3.h RGWListBuckets_ObjStore_S3::get_params", parent_span);
+    limit = -1; /* no limit */
+    return 0;
+  }
   void send_response_begin(bool has_buckets) override;
   void send_response_begin(bool has_buckets, Jager_Tracer&, const Span&, Span&) override;
   void send_response_data(rgw::sal::RGWBucketList& buckets) override;
+  void send_response_data(rgw::sal::RGWBucketList& buckets, Jager_Tracer& tracer, const Span& parent_span) override;
   void send_response_end() override;
   void send_response_end(Span,const Span&) override;
 };

src/rgw/rgw_rest_swift.cc

@@ -83,6 +83,11 @@ int RGWListBuckets_ObjStore_SWIFT::get_params()
   return 0;
 }
 
+int RGWListBuckets_ObjStore_SWIFT::get_params(Jager_Tracer& tracer, const Span& parent_span){
+  Span span = tracer.child_span("rgw_rest_swift.cc RGWListBuckets_ObjStore_SWIFT::get_params", parent_span);
+  return RGWListBuckets_ObjStore_SWIFT::get_params();
+}
+
 static void dump_account_metadata(struct req_state * const s,
                                   const RGWUsageStats& global_stats,
                                   const std::map<std::string, RGWUsageStats> &policies_stats,
@@ -194,7 +199,7 @@ void RGWListBuckets_ObjStore_SWIFT::send_response_begin(bool has_buckets)
 
 void RGWListBuckets_ObjStore_SWIFT::send_response_begin(bool has_buckets, Jager_Tracer& tracer, const Span& parent_span, Span& span)
 {
-  span = tracer.child_span("rgw_rest_swift.cc RGWListBuckets_ObjStore_SWIFT::send_response", parent_span);
+  span = tracer.child_span("rgw_rest_swift.cc RGWListBuckets_ObjStore_SWIFT::send_response_begin", parent_span);
   RGWListBuckets_ObjStore_SWIFT::send_response_begin(has_buckets);
 }
 
@@ -209,6 +214,18 @@ void RGWListBuckets_ObjStore_SWIFT::handle_listing_chunk(rgw::sal::RGWBucketList
   }
 }
 
+void RGWListBuckets_ObjStore_SWIFT::handle_listing_chunk(rgw::sal::RGWBucketList&& buckets, Jager_Tracer& tracer, const Span& parent_span)
+{
+  Span span = tracer.child_span("rgw_rest_swift.cc RGWListBuckets_ObjStore_SWIFT::handle_listing_chunk", parent_span);
+  if (wants_reversed) {
+    /* Just store in the reversal buffer. Its content will be handled later,
+     * in send_response_end(). */
+    reverse_buffer.emplace(std::begin(reverse_buffer), std::move(buckets));
+  } else {
+    return send_response_data(buckets, tracer, span);
+  }
+}
+
 void RGWListBuckets_ObjStore_SWIFT::send_response_data(rgw::sal::RGWBucketList& buckets)
 {
   if (! sent_data) {
@@ -227,6 +244,12 @@ void RGWListBuckets_ObjStore_SWIFT::send_response_data(rgw::sal::RGWBucketList&
   }
 }
 
+void RGWListBuckets_ObjStore_SWIFT::send_response_data(rgw::sal::RGWBucketList& buckets, Jager_Tracer& tracer, const Span& parent_span)
+{
+  Span span = tracer.child_span("rgw_rest_swift.cc RGWListBuckets_ObjStore_SWIFT::send_response_data", parent_span);
+  RGWListBuckets_ObjStore_SWIFT::send_response_data(buckets);
+}
+
 void RGWListBuckets_ObjStore_SWIFT::dump_bucket_entry(const rgw::sal::RGWBucket& obj)
 {
   s->formatter->open_object_section("container");
@@ -303,6 +326,7 @@ void RGWListBuckets_ObjStore_SWIFT::send_response_end(Span span, const Span& par
 {
   parent_span->SetTag("operation_gateway", "swift");
   RGWListBuckets_ObjStore_SWIFT::send_response_end();
+  span->Finish();
 }
 
 int RGWListBucket_ObjStore_SWIFT::get_params()

src/rgw/rgw_rest_swift.h

@@ -54,10 +54,13 @@ class RGWListBuckets_ObjStore_SWIFT : public RGWListBuckets_ObjStore {
   ~RGWListBuckets_ObjStore_SWIFT() override {}
 
   int get_params() override;
+  int get_params(Jager_Tracer&, const Span&) override;
   void handle_listing_chunk(rgw::sal::RGWBucketList&& buckets) override;
+  void handle_listing_chunk(rgw::sal::RGWBucketList&& buckets, Jager_Tracer&, const Span&) override;
   void send_response_begin(bool has_buckets) override;
   void send_response_begin(bool has_buckets, Jager_Tracer&, const Span&, Span&) override;
   void send_response_data(rgw::sal::RGWBucketList& buckets) override;
+  void send_response_data(rgw::sal::RGWBucketList& buckets, Jager_Tracer&, const Span&) override;
   void send_response_data_reversed(rgw::sal::RGWBucketList& buckets);
   void dump_bucket_entry(const rgw::sal::RGWBucket& obj);
   void send_response_end() override;

src/rgw/rgw_sal.cc

@@ -50,6 +50,28 @@ int RGWRadosUser::list_buckets(const string& marker, const string& end_marker,
   return 0;
 }
 
+int RGWRadosUser::list_buckets(const string& marker, const string& end_marker,
+			       uint64_t max, bool need_stats, RGWBucketList &buckets, Jager_Tracer& tracer, const Span& parent_span)
+{
+  Span span = tracer.child_span("rgw_sal.cc RGWRadosUser::list_buckets", parent_span);
+  RGWUserBuckets ulist;
+  bool is_truncated = false;
+  int ret;
+
+  ret = store->ctl()->user->list_buckets(info.user_id, marker, end_marker, max,
+					 need_stats, &ulist, &is_truncated, tracer, span);
+  if (ret < 0)
+    return ret;
+
+  buckets.set_truncated(is_truncated);
+  for (const auto& ent : ulist.get_buckets()) {
+    RGWRadosBucket *rb = new RGWRadosBucket(this->store, *this, ent.second);
+    buckets.add(rb);
+  }
+
+  return 0;
+}
+
 RGWBucketList::~RGWBucketList()
 {
   for (auto itr = buckets.begin(); itr != buckets.end(); itr++) {

src/rgw/rgw_sal.h

@@ -190,6 +190,8 @@ class RGWRadosUser : public RGWUser {
 
     int list_buckets(const string& marker, const string& end_marker,
 				uint64_t max, bool need_stats, RGWBucketList& buckets);
+    int list_buckets(const string& marker, const string& end_marker,
+				uint64_t max, bool need_stats, RGWBucketList& buckets, Jager_Tracer&, const Span&);
     RGWBucket* add_bucket(rgw_bucket& bucket, ceph::real_time creation_time);
 
     /* Placeholders */