Otlp http log example

examples/common/CMakeLists.txt

@@ -1 +1,4 @@
 add_subdirectory(foo_library)
+if(WITH_LOGS_PREVIEW)
+  add_subdirectory(logs_foo_library)
+endif()

examples/common/logs_foo_library/BUILD

@@ -0,0 +1,16 @@
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "common_logs_foo_library",
+    srcs = [
+        "foo_library.cc",
+    ],
+    hdrs = [
+        "foo_library.h",
+    ],
+    defines = ["BAZEL_BUILD"],
+    deps = [
+        "//api",
+        "//sdk:headers",
+    ],
+)

examples/common/logs_foo_library/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_library(common_logs_foo_library foo_library.h foo_library.cc)
+target_link_libraries(common_logs_foo_library PUBLIC ${CMAKE_THREAD_LIBS_INIT}
+                                                     opentelemetry_api)

examples/common/logs_foo_library/foo_library.cc

@@ -0,0 +1,40 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#ifdef ENABLE_LOGS_PREVIEW
+#  include <map>
+#  include <string>
+#  include "opentelemetry/logs/provider.h"
+#  include "opentelemetry/sdk/version/version.h"
+#  include "opentelemetry/trace/provider.h"
+
+namespace logs  = opentelemetry::logs;
+namespace trace = opentelemetry::trace;
+namespace nostd = opentelemetry::nostd;
+
+namespace
+{
+nostd::shared_ptr<trace::Tracer> get_tracer()
+{
+  auto provider = trace::Provider::GetTracerProvider();
+  return provider->GetTracer("foo_library", OPENTELEMETRY_SDK_VERSION);
+}
+
+nostd::shared_ptr<logs::Logger> get_logger()
+{
+  auto provider = logs::Provider::GetLoggerProvider();
+  return provider->GetLogger("foo_library_logger", nostd::span<nostd::string_view>());
+}
+}  // namespace
+
+void foo_library()
+{
+  auto span        = get_tracer()->StartSpan("span 1");
+  auto scoped_span = trace::Scope(get_tracer()->StartSpan("foo_library"));
+  auto ctx         = span->GetContext();
+  auto logger      = get_logger();
+  logger->Log(opentelemetry::logs::Severity::kDebug, "name", "body",
+              std::map<std::string, std::string>(), std::map<std::string, std::string>(),
+              ctx.trace_id(), ctx.span_id(), ctx.trace_flags(),
+              opentelemetry::common::SystemTimestamp());
+}
+#endif

examples/common/logs_foo_library/foo_library.h

@@ -0,0 +1,6 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+void foo_library();

examples/otlp/BUILD

@@ -23,3 +23,17 @@ cc_binary(
         "//sdk/src/trace",
     ],
 )
+
+cc_binary(
+    name = "example_otlp_http_log",
+    srcs = [
+        "http_log_main.cc",
+    ],
+    deps = [
+        "//api",
+        "//examples/common/logs_foo_library:common_logs_foo_library",
+        "//exporters/otlp:otlp_http_exporter",
+        "//exporters/otlp:otlp_http_log_exporter",
+        "//sdk/src/trace",
+    ],
+)

examples/otlp/CMakeLists.txt

@@ -14,4 +14,15 @@ if(WITH_OTLP_HTTP)
   target_link_libraries(
     example_otlp_http ${CMAKE_THREAD_LIBS_INIT} common_foo_library
     opentelemetry_trace opentelemetry_exporter_otlp_http)
+  if(WITH_LOGS_PREVIEW)
+    add_executable(example_otlp_http_log http_log_main.cc)
+    target_link_libraries(
+      example_otlp_http_log
+      ${CMAKE_THREAD_LIBS_INIT}
+      common_logs_foo_library
+      opentelemetry_trace
+      opentelemetry_logs
+      opentelemetry_exporter_otlp_http
+      opentelemetry_exporter_otlp_http_log)
+  endif()
 endif()

examples/otlp/README.md

@@ -4,8 +4,9 @@ This is an example of how to use the [OpenTelemetry
 Protocol](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/README.md)
 (OTLP) exporter.
 
-The application in `grpc_main.cc` initializes an `OtlpGrpcExporter` instance and
-the application in `http_main.cc` initializes an `OtlpHttpExporter` instance
+The application in `grpc_main.cc` initializes an `OtlpGrpcExporter` instance,
+the application in `http_main.cc` initializes an `OtlpHttpExporter` instance.
+The application in `http_log_main.cc` initializes an `OtlpHttpLogExporter` instance
 and they register a tracer provider from the [OpenTelemetry
 SDK](https://github.com/open-telemetry/opentelemetry-cpp). The application then
 calls a `foo_library` which has been instrumented using the [OpenTelemetry

examples/otlp/http_log_main.cc

@@ -0,0 +1,93 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+#  include "opentelemetry/exporters/otlp/otlp_http_exporter.h"
+#  include "opentelemetry/exporters/otlp/otlp_http_log_exporter.h"
+#  include "opentelemetry/logs/provider.h"
+#  include "opentelemetry/sdk/logs/logger_provider.h"
+#  include "opentelemetry/sdk/logs/simple_log_processor.h"
+#  include "opentelemetry/sdk/trace/simple_processor.h"
+#  include "opentelemetry/sdk/trace/tracer_provider.h"
+#  include "opentelemetry/trace/provider.h"
+
+#  include <string>
+
+#  ifdef BAZEL_BUILD
+#    include "examples/common/logs_foo_library/foo_library.h"
+#  else
+#    include "logs_foo_library/foo_library.h"
+#  endif
+
+namespace trace    = opentelemetry::trace;
+namespace nostd    = opentelemetry::nostd;
+namespace otlp     = opentelemetry::exporter::otlp;
+namespace sdklogs  = opentelemetry::sdk::logs;
+namespace logs_api = opentelemetry::logs;
+
+namespace sdktrace = opentelemetry::sdk::trace;
+
+namespace
+{
+
+opentelemetry::exporter::otlp::OtlpHttpExporterOptions opts;
+void InitTracer()
+{
+  // Create OTLP exporter instance
+  auto exporter  = std::unique_ptr<sdktrace::SpanExporter>(new otlp::OtlpHttpExporter(opts));
+  auto processor = std::unique_ptr<sdktrace::SpanProcessor>(
+      new sdktrace::SimpleSpanProcessor(std::move(exporter)));
+  auto provider =
+      nostd::shared_ptr<trace::TracerProvider>(new sdktrace::TracerProvider(std::move(processor)));
+  // Set the global trace provider
+  trace::Provider::SetTracerProvider(provider);
+}
+
+opentelemetry::exporter::otlp::OtlpHttpLogExporterOptions logger_opts;
+void InitLogger()
+{
+  logger_opts.console_debug = true;
+  // Create OTLP exporter instance
+  auto exporter = std::unique_ptr<sdklogs::LogExporter>(new otlp::OtlpHttpLogExporter(logger_opts));
+  auto processor =
+      std::shared_ptr<sdklogs::LogProcessor>(new sdklogs::SimpleLogProcessor(std::move(exporter)));
+  auto sdkProvider = std::shared_ptr<sdklogs::LoggerProvider>(new sdklogs::LoggerProvider());
+  sdkProvider->SetProcessor(processor);
+  auto apiProvider = nostd::shared_ptr<logs_api::LoggerProvider>(sdkProvider);
+  auto provider    = nostd::shared_ptr<logs_api::LoggerProvider>(apiProvider);
+  opentelemetry::logs::Provider::SetLoggerProvider(provider);
+}
+}  // namespace
+
+int main(int argc, char *argv[])
+{
+  if (argc > 1)
+  {
+    opts.url        = argv[1];
+    logger_opts.url = argv[1];
+    if (argc > 2)
+    {
+      std::string debug  = argv[2];
+      opts.console_debug = debug != "" && debug != "0" && debug != "no";
+    }
+
+    if (argc > 3)
+    {
+      std::string binary_mode = argv[3];
+      if (binary_mode.size() >= 3 && binary_mode.substr(0, 3) == "bin")
+      {
+        opts.content_type        = opentelemetry::exporter::otlp::HttpRequestContentType::kBinary;
+        logger_opts.content_type = opentelemetry::exporter::otlp::HttpRequestContentType::kBinary;
+      }
+    }
+  }
+  InitLogger();
+  InitTracer();
+  foo_library();
+}
+#else
+int main()
+{
+  return 0;
+}
+#endif