Merge branch 'main' into wip-thrift

CONTRIBUTING.md

@@ -97,6 +97,13 @@ git commit
 git push fork feature
 ```
 
+If you made changes to the Markdown documents (`*.md` files), install the latest
+[`markdownlint-cli`](https:/igorshubovych/markdownlint-cli) and run:
+
+```sh
+markdownlint .
+```
+
 Open a pull request against the main `opentelemetry-cpp` repo.
 
 To run tests locally, please read the [CI instructions](ci/README.md).
@@ -144,6 +151,14 @@ If none of the above worked and the PR has been stuck for more than 2 weeks, the
 owner should bring it to the OpenTelemetry C++ SIG meeting. See
 [README.md](README.md#contributing) for the meeting link.
 
+## Design Choices
+
+As with other OpenTelemetry clients, opentelemetry-cpp follows the
+[opentelemetry-specification](https:/open-telemetry/opentelemetry-specification).
+
+It's especially valuable to read through the [library
+guidelines](https:/open-telemetry/opentelemetry-specification/blob/main/specification/library-guidelines.md).
+
 ## Useful Resources
 
 Hi! If you’re looking at this document, these resources will provide you the
@@ -168,43 +183,13 @@ the C++ repository.
  * The OpenTelemetry Specification describes the requirements and expectations
  of for all OpenTelemetry implementations.
 
-* Read through the [OpenTelemetry
- Collector](https:/open-telemetry/opentelemetry-collector) GitHub
- repository.
- * This repository has a lot of good information surrounding the OpenTelemetry
- ecosystem. At the top of the
- **[readme](https:/open-telemetry/opentelemetry-collector/blob/main/README.md)**,
- there are multiple links that give newcomers a good idea of what the project
- is about and how to get involved in it.
-* Read through the OpenTelemetry Python documentation
+* Read through the OpenTelemetry C++ documentation
  * The
- [API](https://opentelemetry-python.readthedocs.io/en/stable/api/api.html)
+ [API](https://opentelemetry-cpp.readthedocs.io/en/latest/api/api.html)
  and
- [SDK](https://opentelemetry-python.readthedocs.io/en/stable/sdk/sdk.html)
+ [SDK](https://opentelemetry-cpp.readthedocs.io/en/latest/sdk/sdk.html)
  documentation provides a lot of information on what the classes and their
- functions are used for. Since there is currently minimal documentation for
- C++, use the Python repository’s extensive documentation to learn more about
- how the API and SDK work.
-
-### Code Examples
-
-* Follow the [simple trace
- example](https:/open-telemetry/opentelemetry-cpp/pull/92) for an
- introduction to basic OpenTelemetry functionality in C++. Currently the
- example can be found in [PR
- #94](https:/open-telemetry/opentelemetry-cpp/pull/94).
-
-* Read through the [Java Quick-Start
- Guide](https:/open-telemetry/opentelemetry-java/blob/main/QUICKSTART.md).
- This shows you how the classes and functions will interact in simple and easy
- to digest examples.
-* Take a look at this [Java SDK
- example](https:/open-telemetry/opentelemetry-java/tree/main/examples/sdk-usage).
- This shows a good use case of the SDK using stdout exporter.
-* Take a look at the [Java Jaeger
- example](https:/open-telemetry/opentelemetry-java/tree/main/examples/jaeger).
- This provides a brief introduction to the Jaeger exporter, its interface, and
- how to interact with the service.
+ functions are used for.
 
 Please contribute! You’re welcome to add more information if you come across any
 helpful resources.

README.md

@@ -50,7 +50,7 @@ of the current project.
 
 | Platform | Build type |
 |---------------------------------------------------------------------|---------------|
-| ubuntu-18.04 (Default GCC Compiler - 7.5.0) | CMake, Bazel |
+| ubuntu-20.04 (Default GCC Compiler - 9.3.0) | CMake, Bazel |
 | ubuntu-18.04 (GCC 4.8 with -std=c++11 flag) | CMake [1] |
 | ubuntu-20.04 (Default GCC Compiler - 9.3.0 with -std=c++20 flags) | CMake, Bazel |
 | macOS 10.15 (Xcode 12.2) | Bazel |

docs/public/sdk/GettingStarted.rst

@@ -66,7 +66,7 @@ OpenTelemetry offers six tracing exporters out of the box:
 
  // otlp http exporter
  opentelemetry::exporter::otlp::OtlpHttpExporterOptions opts;
- opts.url = "http://localhost:4317/v1/traces";
+ opts.url = "http://localhost:4318/v1/traces";
  auto otlp_http_exporter =
  std::unique_ptr<sdktrace::SpanExporter>(new opentelemetry::exporter::otlp::OtlpHttpExporter(opts));
 

examples/otlp/README.md

@@ -32,19 +32,18 @@ OpenTelemetry Collector with an OTLP receiver by running:
 - On Unix based systems use:
 
 ```console
-docker run --rm -it -p 4317:4317 -p 55681:55681 -v $(pwd)/examples/otlp:/cfg otel/opentelemetry-collector:0.19.0 --config=/cfg/opentelemetry-collector-config/config.dev.yaml
+docker run --rm -it -p 4317:4317 -p 4318:4318 -v $(pwd)/examples/otlp:/cfg otel/opentelemetry-collector:0.19.0 --config=/cfg/opentelemetry-collector-config/config.dev.yaml
 ```
 
 - On Windows use:
 
 ```console
-docker run --rm -it -p 4317:4317 -p 55681:55681 -v "%cd%/examples/otlp":/cfg otel/opentelemetry-collector:0.19.0 --config=/cfg/opentelemetry-collector-config/config.dev.yaml
+docker run --rm -it -p 4317:4317 -p 4318:4318 -v "%cd%/examples/otlp":/cfg otel/opentelemetry-collector:0.19.0 --config=/cfg/opentelemetry-collector-config/config.dev.yaml
 ```
 
-Note that the OTLP exporter connects to the Collector at `localhost:4317` by
-default. This can be changed with first argument from command-line, for example:
+Note that the OTLP gRPC and HTTP exporters connects to the Collector at `localhost:4317` and `localhost:4318:/v1/traces` respectively. This can be changed with first argument from command-line, for example:
 `./example_otlp_grpc gateway.docker.internal:4317` and
-`./example_otlp_http gateway.docker.internal:55681/v1/traces`.
+`./example_otlp_http gateway.docker.internal:4318/v1/traces`.
 
 Once you have the Collector running, see
 [CONTRIBUTING.md](../../CONTRIBUTING.md) for instructions on building and

examples/otlp/opentelemetry-collector-config/config.dev.yaml

@@ -7,7 +7,7 @@ receivers:
  grpc:
  endpoint: 0.0.0.0:4317
  http:
- endpoint: "0.0.0.0:55681"
+ endpoint: "0.0.0.0:4318"
  cors_allowed_origins:
  - '*'
 service:

exporters/etw/include/opentelemetry/exporters/etw/etw_logger.h

@@ -76,7 +76,7 @@ class Logger : public logs::Logger
  {
  static ETWProvider instance; // C++11 magic static
  return instance;
- };
+ }
 
  /**
  * @brief Init a reference to etw::ProviderHandle

exporters/etw/include/opentelemetry/exporters/etw/etw_properties.h

@@ -83,7 +83,7 @@ class PropertyValue : public PropertyVariant
  static std::vector<T> to_vector(const nostd::span<const T, nostd::dynamic_extent> &source)
  {
  return std::vector<T>(source.begin(), source.end());
- };
+ }
 
  /**
  * @brief Convert span<string_view> to vector<string>
@@ -98,7 +98,7 @@ class PropertyValue : public PropertyVariant
  result.push_back(std::string(item.data()));
  }
  return result;
- };
+ }
 
  /**
  * @brief Convert vector<INTEGRAL> to span<INTEGRAL>.
@@ -111,7 +111,7 @@ class PropertyValue : public PropertyVariant
  {
  nostd::span<const T> result(vec.data(), vec.size());
  return result;
- };
+ }
 
  /**
  * @brief Convert vector<FLOAT> to span<const FLOAT>.
@@ -124,69 +124,72 @@ class PropertyValue : public PropertyVariant
  {
  nostd::span<const T> result(vec.data(), vec.size());
  return result;
- };
+ }
 
 public:
  /**
  * @brief PropertyValue from bool
  * @param v
  * @return
  */
- PropertyValue(bool value) : PropertyVariant(value){};
+ PropertyValue(bool value) : PropertyVariant(value) {}
 
  /**
  * @brief PropertyValue from integral.
  * @param v
  * @return
  */
  template <typename TInteger, std::enable_if_t<std::is_integral<TInteger>::value, bool> = true>
- PropertyValue(TInteger number) : PropertyVariant(number){};
+ PropertyValue(TInteger number) : PropertyVariant(number)
+ {}
 
  /**
  * @brief PropertyValue from floating point.
  * @param v
  * @return
  */
  template <typename TFloat, std::enable_if_t<std::is_floating_point<TFloat>::value, bool> = true>
- PropertyValue(TFloat number) : PropertyVariant(double(number)){};
+ PropertyValue(TFloat number) : PropertyVariant(double(number))
+ {}
 
  /**
  * @brief Default PropertyValue (int32_t=0)
  * @param v
  * @return
  */
- PropertyValue() : PropertyVariant(int32_t(0)){};
+ PropertyValue() : PropertyVariant(int32_t(0)) {}
 
  /**
  * @brief PropertyValue from array of characters as string.
  *
  * @param v
  * @return
  */
- PropertyValue(char value[]) : PropertyVariant(std::string(value)){};
+ PropertyValue(char value[]) : PropertyVariant(std::string(value)) {}
 
  /**
  * @brief PropertyValue from array of characters as string.
  *
  * @param v
  * @return
  */
- PropertyValue(const char *value) : PropertyVariant(std::string(value)){};
+ PropertyValue(const char *value) : PropertyVariant(std::string(value)) {}
 
  /**
  * @brief PropertyValue from string.
  *
  * @param v
  * @return
  */
- PropertyValue(const std::string &value) : PropertyVariant(value){};
+ PropertyValue(const std::string &value) : PropertyVariant(value) {}
 
  /**
  * @brief PropertyValue from vector as array.
  * @return
  */
  template <typename T>
- PropertyValue(std::vector<T> value) : PropertyVariant(value){};
+ PropertyValue(std::vector<T> value) : PropertyVariant(value)
+ {}
 
  /**
  * @brief Convert owning PropertyValue to non-owning common::AttributeValue
@@ -217,11 +220,11 @@ class PropertyValue : public PropertyVariant
  case common::AttributeType::kTypeCString: {
  PropertyVariant::operator=(nostd::get<const char *>(v));
  break;
- };
+ }
  case common::AttributeType::kTypeString: {
  PropertyVariant::operator=(nostd::string_view(nostd::get<nostd::string_view>(v)).data());
  break;
- };
+ }
 
  case common::AttributeType::kTypeSpanByte:
  PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const uint8_t>>(v)));
@@ -361,15 +364,15 @@ class Properties : public common::KeyValueIterable, public PropertyValueMap
  /**
  * @brief PropertyValueMap constructor.
  */
- Properties() : PropertyValueMap(){};
+ Properties() : PropertyValueMap() {}
 
  /**
  * @brief PropertyValueMap constructor from initializer list.
  */
  Properties(const std::initializer_list<PropertyValueType> properties) : PropertyValueMap()
  {
  (*this) = (properties);
- };
+ }
 
  /**
  * @brief PropertyValueMap assignment operator from initializer list.
@@ -378,12 +381,12 @@ class Properties : public common::KeyValueIterable, public PropertyValueMap
  {
  PropertyValueMap::operator=(properties);
  return (*this);
- };
+ }
 
  /**
  * @brief PropertyValueMap constructor from map.
  */
- Properties(const PropertyValueMap &properties) : PropertyValueMap() { (*this) = properties; };
+ Properties(const PropertyValueMap &properties) : PropertyValueMap() { (*this) = properties; }
 
  /**
  * @brief PropertyValueMap assignment operator from map.
@@ -392,7 +395,7 @@ class Properties : public common::KeyValueIterable, public PropertyValueMap
  {
  PropertyValueMap::operator=(properties);
  return (*this);
- };
+ }
 
  /**
  * @brief PropertyValueMap constructor from KeyValueIterable
@@ -414,7 +417,7 @@ class Properties : public common::KeyValueIterable, public PropertyValueMap
  return true;
  });
  return (*this);
- };
+ }
 
  /**
  * @brief PropertyValueMap property accessor.
@@ -439,12 +442,12 @@ class Properties : public common::KeyValueIterable, public PropertyValueMap
  }
  }
  return true;
- };
+ }
 
  /**
  * @return the number of key-value pairs
  */
- size_t size() const noexcept override { return PropertyValueMap::size(); };
+ size_t size() const noexcept override { return PropertyValueMap::size(); }
 };
 
 } // namespace etw