uniform alias name of *Ptr and make_* usage (#111)

wbpcode · web-flow · commit 9530d6221df5 · 2022-10-07T12:36:56.000+08:00
diff --git a/README.md b/README.md
@@ -87,23 +87,23 @@ Tracing span will be delivered from `sw8` and `sw8-x` HTTP headers. For more det
 Then, you can create propagated span object by decoding these items.
 
 ```cpp
-SpanContextPtr parent_span = createSpanContext(parent);
+SpanContextSharedPtr parent_span = createSpanContext(parent);
 ```
 
 #### Create span
 
 First, you must create tracing context that holds all spans, then crete initial entry span.
 
 ```cpp
-TracingContextPtr tracing_context = tracer->newContext();
-TracingSpanPtr tracing_span = tracing_context->createEntrySpan();
+TracingContextSharedPtr tracing_context = tracer->newContext();
+TracingSpanSharedPtr tracing_span = tracing_context->createEntrySpan();
 ```
 
 After that, you can create another span to trace another workload, such as RPC to other services.
 Note that you must have parent span to create secondary span. It will construct parent-child relation when analysis.
 
 ```cpp
-TracingSpanPtr current_span = tracing_context->createExitSpan(current_span);
+TracingSpanSharedPtr current_span = tracing_context->createExitSpan(current_span);
 ```
 
 Alternative approach is RAII based one. It is used like below,
@@ -125,8 +125,8 @@ Note that TracingContext is unique pointer. So when you'd like to send data, you
 to avoid undefined behavior.
 
 ```cpp
-TracingContextPtr tracing_context = tracer->newContext();
-TracingSpanPtr tracing_span = tracing_context->createEntrySpan();
+TracingContextSharedPtr tracing_context = tracer->newContext();
+TracingSpanSharedPtr tracing_span = tracing_context->createEntrySpan();
 
 tracing_span->startSpan("sample_workload");
 tracing_span->endSpan();
diff --git a/cpp2sky/internal/async_client.h b/cpp2sky/internal/async_client.h
@@ -138,6 +138,7 @@ struct StreamCallbackTag {
 };
 
 template <class RequestType, class ResponseType>
-using AsyncStreamPtr = std::shared_ptr<AsyncStream<RequestType, ResponseType>>;
+using AsyncStreamSharedPtr =
+    std::shared_ptr<AsyncStream<RequestType, ResponseType>>;
 
 }  // namespace cpp2sky
diff --git a/cpp2sky/internal/stream_builder.h b/cpp2sky/internal/stream_builder.h
@@ -28,7 +28,7 @@ class ClientStreamingStreamBuilder {
   /**
    * Create async stream entity
    */
-  virtual AsyncStreamPtr<RequestType, ResponseType> create(
+  virtual AsyncStreamSharedPtr<RequestType, ResponseType> create(
       AsyncClient<RequestType, ResponseType>& client,
       std::condition_variable& cv) = 0;
 };
@@ -45,7 +45,7 @@ class UnaryStreamBuilder {
   /**
    * Create async stream entity
    */
-  virtual AsyncStreamPtr<RequestType, ResponseType> create(
+  virtual AsyncStreamSharedPtr<RequestType, ResponseType> create(
       AsyncClient<RequestType, ResponseType>& client, RequestType request) = 0;
 };
 
diff --git a/cpp2sky/propagation.h b/cpp2sky/propagation.h
@@ -69,7 +69,7 @@ class SpanContext {
   virtual const std::string& targetAddress() const = 0;
 };
 
-using SpanContextPtr = std::shared_ptr<SpanContext>;
+using SpanContextSharedPtr = std::shared_ptr<SpanContext>;
 
 enum class TracingMode {
   Default,
@@ -85,10 +85,10 @@ class SpanContextExtension {
   virtual TracingMode tracingMode() const = 0;
 };
 
-using SpanContextExtensionPtr = std::shared_ptr<SpanContextExtension>;
+using SpanContextExtensionSharedPtr = std::shared_ptr<SpanContextExtension>;
 
-SpanContextPtr createSpanContext(absl::string_view ctx);
+SpanContextSharedPtr createSpanContext(absl::string_view ctx);
 
-SpanContextExtensionPtr createSpanContextExtension(absl::string_view ctx);
+SpanContextExtensionSharedPtr createSpanContextExtension(absl::string_view ctx);
 
 }  // namespace cpp2sky
diff --git a/cpp2sky/tracer.h b/cpp2sky/tracer.h
@@ -29,13 +29,13 @@ class Tracer {
   /**
    * Start new segment. It will be called per request, for example.
    */
-  virtual TracingContextPtr newContext() = 0;
-  virtual TracingContextPtr newContext(SpanContextPtr span) = 0;
+  virtual TracingContextSharedPtr newContext() = 0;
+  virtual TracingContextSharedPtr newContext(SpanContextSharedPtr span) = 0;
 
   /**
    * Send SegmentContext to the collector.
    */
-  virtual bool report(TracingContextPtr obj) = 0;
+  virtual bool report(TracingContextSharedPtr obj) = 0;
 };
 
 using TracerPtr = std::unique_ptr<Tracer>;
diff --git a/cpp2sky/tracing_context.h b/cpp2sky/tracing_context.h
@@ -175,7 +175,7 @@ class TracingSpan {
   virtual bool finished() const = 0;
 };
 
-using TracingSpanPtr = std::shared_ptr<TracingSpan>;
+using TracingSpanSharedPtr = std::shared_ptr<TracingSpan>;
 
 class TracingContext {
  public:
@@ -204,28 +204,29 @@ class TracingContext {
   /**
    * Get spans generated by this segment context.
    */
-  virtual const std::list<TracingSpanPtr>& spans() const = 0;
+  virtual const std::list<TracingSpanSharedPtr>& spans() const = 0;
 
   /**
    * Get span context which generated this segment context as parent.
    */
-  virtual SpanContextPtr parentSpanContext() const = 0;
+  virtual SpanContextSharedPtr parentSpanContext() const = 0;
 
   /**
    * Get span context extension which generated this segment context.
    */
-  virtual SpanContextExtensionPtr parentSpanContextExtension() const = 0;
+  virtual SpanContextExtensionSharedPtr parentSpanContextExtension() const = 0;
 
   /**
    * Generate a segment span related with this segment context.
    * @param parent_span Parent span which is extracted from caller.
    */
-  virtual TracingSpanPtr createExitSpan(TracingSpanPtr parent_span) = 0;
+  virtual TracingSpanSharedPtr createExitSpan(
+      TracingSpanSharedPtr parent_span) = 0;
 
   /**
    * Generate root segment span, called once per workload.
    */
-  virtual TracingSpanPtr createEntrySpan() = 0;
+  virtual TracingSpanSharedPtr createEntrySpan() = 0;
 
   /**
    * Generate sw8 value to send SegmentRef.
@@ -264,15 +265,15 @@ class TracingContext {
   virtual std::string logMessage(absl::string_view message) const = 0;
 };
 
-using TracingContextPtr = std::shared_ptr<TracingContext>;
+using TracingContextSharedPtr = std::shared_ptr<TracingContext>;
 
 /**
  * RAII based span creation. It acquired then create new span with required
  * properties. The span wiil be closed and set end time when called destructor.
  */
 class StartEntrySpan {
  public:
-  StartEntrySpan(TracingContextPtr tracing_context,
+  StartEntrySpan(TracingContextSharedPtr tracing_context,
                  absl::string_view operation_name)
       : span_(tracing_context->createEntrySpan()) {
     span_->startSpan(operation_name.data());
@@ -283,15 +284,16 @@ class StartEntrySpan {
     span_->endSpan();
   }
 
-  TracingSpanPtr get() { return span_; }
+  TracingSpanSharedPtr get() { return span_; }
 
  private:
-  TracingSpanPtr span_;
+  TracingSpanSharedPtr span_;
 };
 
 class StartExitSpan {
  public:
-  StartExitSpan(TracingContextPtr tracing_context, TracingSpanPtr parent_span,
+  StartExitSpan(TracingContextSharedPtr tracing_context,
+                TracingSpanSharedPtr parent_span,
                 absl::string_view operation_name)
       : span_(tracing_context->createExitSpan(parent_span)) {
     span_->startSpan(operation_name.data());
@@ -302,10 +304,10 @@ class StartExitSpan {
     span_->endSpan();
   }
 
-  TracingSpanPtr get() { return span_; }
+  TracingSpanSharedPtr get() { return span_; }
 
  private:
-  TracingSpanPtr span_;
+  TracingSpanSharedPtr span_;
 };
 
 }  // namespace cpp2sky
diff --git a/example/sample.cc b/example/sample.cc
@@ -42,7 +42,7 @@ int main() {
   svr.Get("/ping", [&](const httplib::Request& req, httplib::Response& res) {
     std::string context = req.get_header_value(kPropagationHeader.data());
 
-    TracingContextPtr tracing_context;
+    TracingContextSharedPtr tracing_context;
 
     if (!context.empty()) {
       // 2. Create tracing context with propagated information.
diff --git a/source/cds_impl.cc b/source/cds_impl.cc
@@ -76,7 +76,7 @@ void GrpcAsyncConfigDiscoveryServiceStream::onReadDone() {
   // But it will be destroyed when new stream created.
 }
 
-AsyncStreamPtr<CdsRequest, CdsResponse>
+AsyncStreamSharedPtr<CdsRequest, CdsResponse>
 GrpcAsyncConfigDiscoveryServiceStreamBuilder::create(
     AsyncClient<CdsRequest, CdsResponse>& client, CdsRequest request) {
   return std::make_shared<GrpcAsyncConfigDiscoveryServiceStream>(
diff --git a/source/cds_impl.h b/source/cds_impl.h
@@ -51,7 +51,7 @@ class GrpcAsyncConfigDiscoveryServiceClient final
   UnaryStreamBuilderPtr<CdsRequest, CdsResponse> builder_;
   grpc::CompletionQueue& cq_;
   grpc::TemplatedGenericStub<CdsRequest, CdsResponse> stub_;
-  AsyncStreamPtr<CdsRequest, CdsResponse> stream_;
+  AsyncStreamSharedPtr<CdsRequest, CdsResponse> stream_;
 };
 
 class GrpcAsyncConfigDiscoveryServiceStream final
@@ -92,7 +92,7 @@ class GrpcAsyncConfigDiscoveryServiceStreamBuilder final
       : config_(config) {}
 
   // AsyncStreamFactory
-  AsyncStreamPtr<CdsRequest, CdsResponse> create(
+  AsyncStreamSharedPtr<CdsRequest, CdsResponse> create(
       AsyncClient<CdsRequest, CdsResponse>& client,
       CdsRequest request) override;
 
diff --git a/source/grpc_async_client_impl.cc b/source/grpc_async_client_impl.cc
@@ -149,7 +149,7 @@ void GrpcAsyncSegmentReporterStream::onWriteDone() {
   onIdle();
 }
 
-AsyncStreamPtr<TracerRequestType, TracerResponseType>
+AsyncStreamSharedPtr<TracerRequestType, TracerResponseType>
 GrpcAsyncSegmentReporterStreamBuilder::create(
     AsyncClient<TracerRequestType, TracerResponseType>& client,
     std::condition_variable& cv) {
diff --git a/source/grpc_async_client_impl.h b/source/grpc_async_client_impl.h
@@ -71,7 +71,7 @@ class GrpcAsyncSegmentReporterClient final
       factory_;
   grpc::CompletionQueue& cq_;
   grpc::TemplatedGenericStub<TracerRequestType, TracerResponseType> stub_;
-  AsyncStreamPtr<TracerRequestType, TracerResponseType> stream_;
+  AsyncStreamSharedPtr<TracerRequestType, TracerResponseType> stream_;
   CircularBuffer<TracerRequestType> pending_messages_{
       pending_message_buffer_size};
 
@@ -122,7 +122,7 @@ class GrpcAsyncSegmentReporterStreamBuilder final
       : token_(token) {}
 
   // ClientStreamingStreamBuilder
-  AsyncStreamPtr<TracerRequestType, TracerResponseType> create(
+  AsyncStreamSharedPtr<TracerRequestType, TracerResponseType> create(
       AsyncClient<TracerRequestType, TracerResponseType>& client,
       std::condition_variable& cv) override;
 
diff --git a/source/propagation_impl.cc b/source/propagation_impl.cc
@@ -112,12 +112,13 @@ SpanContextExtensionImpl::SpanContextExtensionImpl(
   }
 }
 
-SpanContextPtr createSpanContext(absl::string_view ctx) {
-  return absl::make_unique<SpanContextImpl>(ctx);
+SpanContextSharedPtr createSpanContext(absl::string_view ctx) {
+  return std::make_shared<SpanContextImpl>(ctx);
 }
 
-SpanContextExtensionPtr createSpanContextExtension(absl::string_view ctx) {
-  return absl::make_unique<SpanContextExtensionImpl>(ctx);
+SpanContextExtensionSharedPtr createSpanContextExtension(
+    absl::string_view ctx) {
+  return std::make_shared<SpanContextExtensionImpl>(ctx);
 }
 
 }  // namespace cpp2sky
diff --git a/source/tracer_impl.cc b/source/tracer_impl.cc
@@ -50,13 +50,15 @@ TracerImpl::~TracerImpl() {
   evloop_thread_.join();
 }
 
-TracingContextPtr TracerImpl::newContext() { return segment_factory_.create(); }
+TracingContextSharedPtr TracerImpl::newContext() {
+  return segment_factory_.create();
+}
 
-TracingContextPtr TracerImpl::newContext(SpanContextPtr span) {
+TracingContextSharedPtr TracerImpl::newContext(SpanContextSharedPtr span) {
   return segment_factory_.create(span);
 }
 
-bool TracerImpl::report(TracingContextPtr obj) {
+bool TracerImpl::report(TracingContextSharedPtr obj) {
   if (!obj || !obj->readyToSend()) {
     return false;
   }
diff --git a/source/tracer_impl.h b/source/tracer_impl.h
@@ -42,10 +42,10 @@ class TracerImpl : public Tracer {
       AsyncClientPtr<TracerRequestType, TracerResponseType> reporter_client);
   ~TracerImpl();
 
-  TracingContextPtr newContext() override;
-  TracingContextPtr newContext(SpanContextPtr span) override;
+  TracingContextSharedPtr newContext() override;
+  TracingContextSharedPtr newContext(SpanContextSharedPtr span) override;
 
-  bool report(TracingContextPtr obj) override;
+  bool report(TracingContextSharedPtr obj) override;
 
  private:
   void init(TracerConfig& config,
diff --git a/source/tracing_context_impl.cc b/source/tracing_context_impl.cc
@@ -134,8 +134,9 @@ void TracingSpanImpl::addSegmentRef(const SpanContext& span_context) {
 
 TracingContextImpl::TracingContextImpl(
     const std::string& service_name, const std::string& instance_name,
-    SpanContextPtr parent_span_context,
-    SpanContextExtensionPtr parent_ext_span_context, RandomGenerator& random)
+    SpanContextSharedPtr parent_span_context,
+    SpanContextExtensionSharedPtr parent_ext_span_context,
+    RandomGenerator& random)
     : parent_span_context_(std::move(parent_span_context)),
       parent_ext_span_context_(std::move(parent_ext_span_context)) {
   segment_store_.set_traceid(
@@ -153,19 +154,20 @@ TracingContextImpl::TracingContextImpl(const std::string& service_name,
 
 TracingContextImpl::TracingContextImpl(const std::string& service_name,
                                        const std::string& instance_name,
-                                       SpanContextPtr parent_span_context,
+                                       SpanContextSharedPtr parent_span_context,
                                        RandomGenerator& random)
     : TracingContextImpl(service_name, instance_name,
                          std::move(parent_span_context), nullptr, random) {}
 
-TracingSpanPtr TracingContextImpl::createExitSpan(TracingSpanPtr parent_span) {
+TracingSpanSharedPtr TracingContextImpl::createExitSpan(
+    TracingSpanSharedPtr parent_span) {
   auto current_span = createSpan();
   current_span->setParentSpanId(parent_span->spanId());
   current_span->setSpanType(skywalking::v3::SpanType::Exit);
   return current_span;
 }
 
-TracingSpanPtr TracingContextImpl::createEntrySpan() {
+TracingSpanSharedPtr TracingContextImpl::createEntrySpan() {
   if (!spans_.empty()) {
     return nullptr;
   }
@@ -191,7 +193,7 @@ absl::optional<std::string> TracingContextImpl::createSW8HeaderValue(
 }
 
 std::string TracingContextImpl::encodeSpan(
-    TracingSpanPtr parent_span, const absl::string_view target_address) {
+    TracingSpanSharedPtr parent_span, const absl::string_view target_address) {
   assert(parent_span);
   std::string header_value;
 
@@ -212,7 +214,7 @@ std::string TracingContextImpl::encodeSpan(
   return header_value;
 }
 
-TracingSpanPtr TracingContextImpl::createSpan() {
+TracingSpanSharedPtr TracingContextImpl::createSpan() {
   auto current_span = std::make_shared<TracingSpanImpl>(spans_.size(), *this);
 
   // It supports only HTTP request tracing.
@@ -260,19 +262,21 @@ TracingContextFactory::TracingContextFactory(const TracerConfig& config)
     : service_name_(config.service_name()),
       instance_name_(config.instance_name()) {}
 
-TracingContextPtr TracingContextFactory::create() {
-  return absl::make_unique<TracingContextImpl>(service_name_, instance_name_,
-                                               random_generator_);
+TracingContextSharedPtr TracingContextFactory::create() {
+  return std::make_shared<TracingContextImpl>(service_name_, instance_name_,
+                                              random_generator_);
 }
 
-TracingContextPtr TracingContextFactory::create(SpanContextPtr span_context) {
-  return absl::make_unique<TracingContextImpl>(service_name_, instance_name_,
-                                               span_context, random_generator_);
+TracingContextSharedPtr TracingContextFactory::create(
+    SpanContextSharedPtr span_context) {
+  return std::make_shared<TracingContextImpl>(service_name_, instance_name_,
+                                              span_context, random_generator_);
 }
 
-TracingContextPtr TracingContextFactory::create(
-    SpanContextPtr span_context, SpanContextExtensionPtr ext_span_context) {
-  auto context = absl::make_unique<TracingContextImpl>(
+TracingContextSharedPtr TracingContextFactory::create(
+    SpanContextSharedPtr span_context,
+    SpanContextExtensionSharedPtr ext_span_context) {
+  auto context = std::make_shared<TracingContextImpl>(
       service_name_, instance_name_, span_context, ext_span_context,
       random_generator_);
   if (ext_span_context->tracingMode() == TracingMode::Skip) {
diff --git a/source/tracing_context_impl.h b/source/tracing_context_impl.h
diff --git a/test/mocks.h b/test/mocks.h
diff --git a/test/tracing_context_test.cc b/test/tracing_context_test.cc

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ void GrpcAsyncConfigDiscoveryServiceStream::onReadDone() {`
`76`	`76`	`// But it will be destroyed when new stream created.`
`77`	`77`	`}`
`78`	`78`
`79`		`-AsyncStreamPtr<CdsRequest, CdsResponse>`
	`79`	`+AsyncStreamSharedPtr<CdsRequest, CdsResponse>`
`80`	`80`	`GrpcAsyncConfigDiscoveryServiceStreamBuilder::create(`
`81`	`81`	`AsyncClient<CdsRequest, CdsResponse>& client, CdsRequest request) {`
`82`	`82`	`return std::make_shared<GrpcAsyncConfigDiscoveryServiceStream>(`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ void GrpcAsyncSegmentReporterStream::onWriteDone() {`
`149`	`149`	`onIdle();`
`150`	`150`	`}`
`151`	`151`
`152`		`-AsyncStreamPtr<TracerRequestType, TracerResponseType>`
	`152`	`+AsyncStreamSharedPtr<TracerRequestType, TracerResponseType>`
`153`	`153`	`GrpcAsyncSegmentReporterStreamBuilder::create(`
`154`	`154`	`AsyncClient<TracerRequestType, TracerResponseType>& client,`
`155`	`155`	`std::condition_variable& cv) {`