diff --git a/.gitignore b/.gitignore
index d6ff6e2..f0bba12 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
+/.cache/
 /.vscode/
 /build*/
diff --git a/src/container_resource_detector.cpp b/src/container_resource_detector.cpp
index 1b41952..70d8147 100644
--- a/src/container_resource_detector.cpp
+++ b/src/container_resource_detector.cpp
@@ -1,11 +1,16 @@
 #include "opentelemetry/resource/wwa/container_resource_detector.h"
 
 #include <fstream>
-#include <regex>
-#include <stdexcept>
 #include <string>
 
-#include <opentelemetry/sdk/resource/semantic_conventions.h>
+#include <opentelemetry/version.h>
+
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+#    include <opentelemetry/sdk/resource/semantic_conventions.h>
+#else
+#    include <opentelemetry/semconv/incubating/container_attributes.h>
+#    include <opentelemetry/semconv/schema_url.h>
+#endif
 
 #include "container_utils.h"
 
@@ -31,12 +36,18 @@ ::opentelemetry::sdk::resource::Resource container_resource_detector::Detect()
         return ::opentelemetry::sdk::resource::Resource::GetEmpty();
     }
 
+#    if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+    using ::opentelemetry::sdk::resource::SemanticConventions::kContainerId;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kSchemaUrl;
+#    else
+    using ::opentelemetry::semconv::container::kContainerId;
+    using ::opentelemetry::semconv::kSchemaUrl;
+#    endif
+
     ::opentelemetry::sdk::resource::ResourceAttributes attrs;
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kContainerId] = cid;
+    attrs[kContainerId] = cid;
 
-    return ::opentelemetry::sdk::resource::Resource::Create(
-        attrs, ::opentelemetry::sdk::resource::SemanticConventions::kSchemaUrl
-    );
+    return ::opentelemetry::sdk::resource::Resource::Create(attrs, kSchemaUrl);
 #endif
 }
 
diff --git a/src/os_resource_detector.cpp b/src/os_resource_detector.cpp
index 01fd85d..3d9f658 100644
--- a/src/os_resource_detector.cpp
+++ b/src/os_resource_detector.cpp
@@ -13,7 +13,15 @@
 #    include "tstring.h"
 #endif
 
-#include <opentelemetry/sdk/resource/semantic_conventions.h>
+#include <opentelemetry/version.h>
+
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+#    include <opentelemetry/sdk/resource/semantic_conventions.h>
+#else
+#    include <opentelemetry/semconv/incubating/host_attributes.h>
+#    include <opentelemetry/semconv/incubating/os_attributes.h>
+#    include <opentelemetry/semconv/schema_url.h>
+#endif
 
 #include "os_utils.h"
 
@@ -23,6 +31,26 @@ ::opentelemetry::sdk::resource::Resource os_resource_detector::Detect()
 {
     ::opentelemetry::sdk::resource::ResourceAttributes attrs;
 
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+    using ::opentelemetry::sdk::resource::SemanticConventions::kHostArch;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kHostName;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kOsType;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kOsVersion;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kSchemaUrl;
+
+    using namespace ::opentelemetry::sdk::resource::SemanticConventions::HostArchValues;
+    using namespace ::opentelemetry::sdk::resource::SemanticConventions::OsTypeValues;
+#else
+    using ::opentelemetry::semconv::host::kHostArch;
+    using ::opentelemetry::semconv::host::kHostName;
+    using ::opentelemetry::semconv::kSchemaUrl;
+    using ::opentelemetry::semconv::os::kOsType;
+    using ::opentelemetry::semconv::os::kOsVersion;
+
+    using namespace ::opentelemetry::semconv::host::HostArchValues;
+    using namespace ::opentelemetry::semconv::os::OsTypeValues;
+#endif
+
 #ifndef _WIN32
     utsname info{};
     if (uname(&info) == -1) {
@@ -30,28 +58,25 @@ ::opentelemetry::sdk::resource::Resource os_resource_detector::Detect()
     }
 
     // NOLINTBEGIN(*-bounds-array-to-pointer-decay) -- we have no control over the system interface
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kHostArch]  = get_host_arch(info.machine);
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kHostName]  = std::string(info.nodename);
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kOsType]    = get_os_type(info.sysname);
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kOsVersion] = std::string(info.release);
+    attrs[kHostArch]  = get_host_arch(info.machine);
+    attrs[kHostName]  = std::string(info.nodename);
+    attrs[kOsType]    = get_os_type(info.sysname);
+    attrs[kOsVersion] = std::string(info.release);
     // NOLINTEND(*-bounds-array-to-pointer-decay)
 #else
     SYSTEM_INFO si{};
     GetSystemInfo(&si);
     switch (si.wProcessorArchitecture) {
         case PROCESSOR_ARCHITECTURE_AMD64:
-            attrs[::opentelemetry::sdk::resource::SemanticConventions::kHostArch] =
-                std::string(::opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kAmd64);
+            attrs[kHostArch] = std::string(kAmd64);
             break;
 
         case PROCESSOR_ARCHITECTURE_INTEL:
-            attrs[::opentelemetry::sdk::resource::SemanticConventions::kHostArch] =
-                std::string(::opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86);
+            attrs[kHostArch] = std::string(kX86);
             break;
 
         case PROCESSOR_ARCHITECTURE_ARM64:
-            attrs[::opentelemetry::sdk::resource::SemanticConventions::kHostArch] =
-                std::string(::opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm64);
+            attrs[kHostArch] = std::string(kArm64);
             break;
 
         default:
@@ -60,28 +85,24 @@ ::opentelemetry::sdk::resource::Resource os_resource_detector::Detect()
 
     std::array<TCHAR, MAX_COMPUTERNAME_LENGTH + 1> buf;
     if (auto size = static_cast<DWORD>(buf.size()); GetComputerName(buf.data(), &size)) {
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kHostName] = convert(buf.data());
+        attrs[kHostName] = convert(buf.data());
     }
 
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kOsType] =
-        std::string(::opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows);
+    attrs[kOsType] = std::string(kWindows);
 
     OSVERSIONINFO osvi{};
     osvi.dwOSVersionInfoSize = sizeof(osvi);
     if (GetVersionEx(&osvi)) {
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kOsVersion] =
-            std::to_string(osvi.dwMajorVersion)
-                .append(".")
-                .append(std::to_string(osvi.dwMinorVersion))
-                .append(" (Build ")
-                .append(std::to_string(osvi.dwBuildNumber))
-                .append(")");
+        attrs[kOsVersion] = std::to_string(osvi.dwMajorVersion)
+                                .append(".")
+                                .append(std::to_string(osvi.dwMinorVersion))
+                                .append(" (Build ")
+                                .append(std::to_string(osvi.dwBuildNumber))
+                                .append(")");
     }
 #endif
 
-    return ::opentelemetry::sdk::resource::Resource::Create(
-        attrs, ::opentelemetry::sdk::resource::SemanticConventions::kSchemaUrl
-    );
+    return ::opentelemetry::sdk::resource::Resource::Create(attrs, kSchemaUrl);
 }
 
 }  // namespace wwa::opentelemetry::resource
diff --git a/src/os_utils.cpp b/src/os_utils.cpp
index 4803512..6e1935d 100644
--- a/src/os_utils.cpp
+++ b/src/os_utils.cpp
@@ -1,6 +1,5 @@
 #include "os_utils.h"
 
-#include <array>
 #include <string_view>
 #include <utility>
 
@@ -9,6 +8,7 @@
 #endif
 
 #if defined(__SIZEOF_INT128__) && __SIZEOF_INT128__ && __cplusplus >= 202002L && !defined(DISABLE_MPH)
+#    include <array>
 #    include <mph>
 #    define USE_MPH
 #    define CONTAINER           std::array
@@ -19,31 +19,45 @@
 #    define CONTAINER_CONSTEXPR const
 #endif
 
-#include <opentelemetry/sdk/resource/semantic_conventions.h>
+#include <opentelemetry/version.h>
+
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+#    include <opentelemetry/sdk/resource/semantic_conventions.h>
+#else
+#    include <opentelemetry/semconv/incubating/host_attributes.h>
+#    include <opentelemetry/semconv/incubating/os_attributes.h>
+#    include <opentelemetry/semconv/schema_url.h>
+#endif
 
 using std::literals::operator""sv;
 
 std::string get_host_arch(std::string_view machine)
 {
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+    using namespace ::opentelemetry::sdk::resource::SemanticConventions::HostArchValues;
+#else
+    using namespace ::opentelemetry::semconv::host::HostArchValues;
+#endif
+
     static CONTAINER_CONSTEXPR auto machine_to_arch = CONTAINER{
-        std::pair{"x86_64"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kAmd64},
-        std::pair{"amd64"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kAmd64},
-        std::pair{"aarch64"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm64},
-        std::pair{"arm64"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm64},
-        std::pair{"arm"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm32},
-        std::pair{"armv7l"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm32},
-        std::pair{"ppc"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kPpc32},
-        std::pair{"ppc64"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kPpc64},
-        std::pair{"ppc64le"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kPpc64},
-        std::pair{"s390x"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kS390x},
-        std::pair{"i386"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86},
-        std::pair{"i486"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86},
-        std::pair{"i586"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86},
-        std::pair{"i686"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86},
-        std::pair{"x86"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86},
-        std::pair{"i86pc"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86},
-        std::pair{"x86pc"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86},
-        std::pair{"ia64"sv, opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kIa64}
+        std::pair{"x86_64"sv, kAmd64},
+        std::pair{"amd64"sv, kAmd64},
+        std::pair{"aarch64"sv, kArm64},
+        std::pair{"arm64"sv, kArm64},
+        std::pair{"arm"sv, kArm32},
+        std::pair{"armv7l"sv, kArm32},
+        std::pair{"ppc"sv, kPpc32},
+        std::pair{"ppc64"sv, kPpc64},
+        std::pair{"ppc64le"sv, kPpc64},
+        std::pair{"s390x"sv, kS390x},
+        std::pair{"i386"sv, kX86},
+        std::pair{"i486"sv, kX86},
+        std::pair{"i586"sv, kX86},
+        std::pair{"i686"sv, kX86},
+        std::pair{"x86"sv, kX86},
+        std::pair{"i86pc"sv, kX86},
+        std::pair{"x86pc"sv, kX86},
+        std::pair{"ia64"sv, kIa64}
     };
 
 #ifdef USE_MPH
@@ -61,18 +75,24 @@ std::string get_host_arch(std::string_view machine)
 
 std::string get_os_type(std::string_view os)
 {
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+    using namespace ::opentelemetry::sdk::resource::SemanticConventions::OsTypeValues;
+#else
+    using namespace ::opentelemetry::semconv::os::OsTypeValues;
+#endif
+
     static CONTAINER_CONSTEXPR auto os_to_type = CONTAINER{
-        std::pair{"Linux"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kLinux},
-        std::pair{"Windows_NT"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows},
-        std::pair{"DragonFly"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kDragonflybsd},
-        std::pair{"FreeBSD"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kFreebsd},
-        std::pair{"HP-UX"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kHpux},
-        std::pair{"AIX"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kAix},
-        std::pair{"Darwin"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kDarwin},
-        std::pair{"NetBSD"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kNetbsd},
-        std::pair{"OpenBSD"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kOpenbsd},
-        std::pair{"SunOS"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kSolaris},
-        std::pair{"OS/390"sv, opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kZOs}
+        std::pair{"Linux"sv, kLinux},
+        std::pair{"Windows_NT"sv, kWindows},
+        std::pair{"DragonFly"sv, kDragonflybsd},
+        std::pair{"FreeBSD"sv, kFreebsd},
+        std::pair{"HP-UX"sv, kHpux},
+        std::pair{"AIX"sv, kAix},
+        std::pair{"Darwin"sv, kDarwin},
+        std::pair{"NetBSD"sv, kNetbsd},
+        std::pair{"OpenBSD"sv, kOpenbsd},
+        std::pair{"SunOS"sv, kSolaris},
+        std::pair{"OS/390"sv, kZOs}
     };
 
 #ifdef USE_MPH
@@ -86,7 +106,7 @@ std::string get_os_type(std::string_view os)
 #endif
 
     if (os.starts_with("CYGWIN") || os.starts_with("MINGW") || os.starts_with("MSYS")) {
-        return opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows;
+        return kWindows;
     }
 
     return {os.data(), os.length()};
diff --git a/src/process_resource_detector.cpp b/src/process_resource_detector.cpp
index abe150a..dae8b7c 100644
--- a/src/process_resource_detector.cpp
+++ b/src/process_resource_detector.cpp
@@ -17,7 +17,14 @@
 #    include "tstring.h"
 #endif
 
-#include <opentelemetry/sdk/resource/semantic_conventions.h>
+#include <opentelemetry/version.h>
+
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+#    include <opentelemetry/sdk/resource/semantic_conventions.h>
+#else
+#    include <opentelemetry/semconv/incubating/process_attributes.h>
+#    include <opentelemetry/semconv/schema_url.h>
+#endif
 
 #include "process_utils.h"
 
@@ -58,82 +65,113 @@ ::opentelemetry::sdk::resource::Resource process_resource_detector::Detect()
 {
     ::opentelemetry::sdk::resource::ResourceAttributes attrs;
 
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessCommand;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessCommandArgs;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessCommandLine;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessGroupLeaderPid;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessInteractive;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessOwner;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessParentPid;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessPid;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessRealUserId;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessRealUserName;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessSavedUserId;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessSavedUserName;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessSessionLeaderPid;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessUserId;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kProcessUserName;
+    using ::opentelemetry::sdk::resource::SemanticConventions::kSchemaUrl;
+#else
+    using ::opentelemetry::semconv::kSchemaUrl;
+    using ::opentelemetry::semconv::process::kProcessCommand;
+    using ::opentelemetry::semconv::process::kProcessCommandArgs;
+    using ::opentelemetry::semconv::process::kProcessCommandLine;
+    using ::opentelemetry::semconv::process::kProcessGroupLeaderPid;
+    using ::opentelemetry::semconv::process::kProcessInteractive;
+    using ::opentelemetry::semconv::process::kProcessOwner;
+    using ::opentelemetry::semconv::process::kProcessParentPid;
+    using ::opentelemetry::semconv::process::kProcessPid;
+    using ::opentelemetry::semconv::process::kProcessRealUserId;
+    using ::opentelemetry::semconv::process::kProcessRealUserName;
+    using ::opentelemetry::semconv::process::kProcessSavedUserId;
+    using ::opentelemetry::semconv::process::kProcessSavedUserName;
+    using ::opentelemetry::semconv::process::kProcessSessionLeaderPid;
+    using ::opentelemetry::semconv::process::kProcessUserId;
+    using ::opentelemetry::semconv::process::kProcessUserName;
+#endif
+
 #ifndef _WIN32
     if (const auto cmdline = get_command_line_args(); !cmdline.empty()) {
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessCommand]     = cmdline[0];
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessCommandArgs] = cmdline;
+        attrs[kProcessCommand]     = cmdline[0];
+        attrs[kProcessCommandArgs] = cmdline;
     }
 #else
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessCommandLine] = convert(GetCommandLine());
+    attrs[kProcessCommandLine] = convert(GetCommandLine());
 #endif
 
 #ifndef _WIN32
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessPid]            = getpid();
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessParentPid]      = getppid();
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessGroupLeaderPid] = getpgid(0);
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessInteractive] =
-        isatty(STDIN_FILENO) == 1 || isatty(STDOUT_FILENO) == 1 || isatty(STDERR_FILENO) == 1;
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessSessionLeaderPid] = getsid(0);
+    attrs[kProcessPid]            = getpid();
+    attrs[kProcessParentPid]      = getppid();
+    attrs[kProcessGroupLeaderPid] = getpgid(0);
+    attrs[kProcessInteractive] = isatty(STDIN_FILENO) == 1 || isatty(STDOUT_FILENO) == 1 || isatty(STDERR_FILENO) == 1;
+    attrs[kProcessSessionLeaderPid] = getsid(0);
 #else
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessPid] =
-        static_cast<std::int64_t>(GetCurrentProcessId());
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessParentPid] =
-        static_cast<std::int64_t>(getppid(GetCurrentProcessId()));
+    attrs[kProcessPid]       = static_cast<std::int64_t>(GetCurrentProcessId());
+    attrs[kProcessParentPid] = static_cast<std::int64_t>(getppid(GetCurrentProcessId()));
 
     int stdin_fileno  = _fileno(stdin);
     int stdout_fileno = _fileno(stdout);
     int stderr_fileno = _fileno(stderr);
 
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessInteractive] =
-        (stdin_fileno >= 0 && isatty(stdin_fileno) == 1) || (stdout_fileno >= 0 && isatty(stdout_fileno) == 1) ||
-        (stderr_fileno >= 0 && isatty(stderr_fileno) == 1);
+    attrs[kProcessInteractive] = (stdin_fileno >= 0 && isatty(stdin_fileno) == 1) ||
+                                 (stdout_fileno >= 0 && isatty(stdout_fileno) == 1) ||
+                                 (stderr_fileno >= 0 && isatty(stderr_fileno) == 1);
 #endif
 
 #if defined(__APPLE__)
     uid_t ruid = getuid();
     uid_t euid = geteuid();
 
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessRealUserId] = ruid;
-    attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessUserId]     = euid;
+    attrs[kProcessRealUserId] = ruid;
+    attrs[kProcessUserId]     = euid;
 #elif defined(__linux__)
     uid_t ruid;  // NOLINT(*-init-variables)
     uid_t euid;  // NOLINT(*-init-variables)
     uid_t suid;  // NOLINT(*-init-variables)
 
     if (getresuid(&ruid, &euid, &suid) == 0) {
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessRealUserId]  = ruid;
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessSavedUserId] = suid;
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessUserId]      = euid;
+        attrs[kProcessRealUserId]  = ruid;
+        attrs[kProcessSavedUserId] = suid;
+        attrs[kProcessUserId]      = euid;
     }
 #endif
 
 #ifndef _WIN32
     if (const auto username = username_by_uid(ruid); !username.empty()) {
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessRealUserName] = username;
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessOwner]        = username;
+        attrs[kProcessRealUserName] = username;
+        attrs[kProcessOwner]        = username;
     }
 
 #    ifndef __APPLE__
     if (const auto username = username_by_uid(suid); !username.empty()) {
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessSavedUserName] = username;
+        attrs[kProcessSavedUserName] = username;
     }
 #    endif
 
     if (const auto username = username_by_uid(euid); !username.empty()) {
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessUserName] = username;
+        attrs[kProcessUserName] = username;
     }
 #else
     std::array<TCHAR, UNLEN + 1> buf;
     if (auto size = static_cast<DWORD>(buf.size()); GetUserName(buf.data(), &size)) {
-        std::string username                                                             = convert(buf.data());
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessRealUserName] = username;
-        attrs[::opentelemetry::sdk::resource::SemanticConventions::kProcessOwner]        = username;
+        std::string username        = convert(buf.data());
+        attrs[kProcessRealUserName] = username;
+        attrs[kProcessOwner]        = username;
     }
 #endif
 
-    return ::opentelemetry::sdk::resource::Resource::Create(
-        attrs, ::opentelemetry::sdk::resource::SemanticConventions::kSchemaUrl
-    );
+    return ::opentelemetry::sdk::resource::Resource::Create(attrs, kSchemaUrl);
 }
 
 }  // namespace wwa::opentelemetry::resource
diff --git a/test/os_utils/get_host_arch.cpp b/test/os_utils/get_host_arch.cpp
index d554cb0..84e3bde 100644
--- a/test/os_utils/get_host_arch.cpp
+++ b/test/os_utils/get_host_arch.cpp
@@ -1,12 +1,24 @@
 #include <tuple>
 
 #include <gtest/gtest.h>
-#include <opentelemetry/sdk/resource/semantic_conventions.h>
+
+#include <opentelemetry/version.h>
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+#    include <opentelemetry/sdk/resource/semantic_conventions.h>
+#else
+#    include <opentelemetry/semconv/incubating/host_attributes.h>
+#endif
 
 #include "os_utils.h"
 
 class GetHostArchTest : public testing::TestWithParam<std::tuple<std::string, std::string>> {};
 
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+using namespace ::opentelemetry::sdk::resource::SemanticConventions::HostArchValues;
+#else
+using namespace ::opentelemetry::semconv::host::HostArchValues;
+#endif
+
 TEST_P(GetHostArchTest, get_host_arch)
 {
     std::string input;
@@ -21,24 +33,24 @@ INSTANTIATE_TEST_SUITE_P(
     Table,
     GetHostArchTest,
     testing::Values(
-        std::make_tuple("x86_64", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kAmd64),
-        std::make_tuple("amd64", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kAmd64),
-        std::make_tuple("aarch64", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm64),
-        std::make_tuple("arm64", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm64),
-        std::make_tuple("arm", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm32),
-        std::make_tuple("armv7l", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kArm32),
-        std::make_tuple("ppc", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kPpc32),
-        std::make_tuple("ppc64", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kPpc64),
-        std::make_tuple("ppc64le", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kPpc64),
-        std::make_tuple("s390x", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kS390x),
-        std::make_tuple("i386", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86),
-        std::make_tuple("i486", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86),
-        std::make_tuple("i586", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86),
-        std::make_tuple("i686", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86),
-        std::make_tuple("x86", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86),
-        std::make_tuple("i86pc", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86),
-        std::make_tuple("x86pc", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kX86),
-        std::make_tuple("ia64", opentelemetry::sdk::resource::SemanticConventions::HostArchValues::kIa64),
+        std::make_tuple("x86_64", kAmd64),
+        std::make_tuple("amd64", kAmd64),
+        std::make_tuple("aarch64", kArm64),
+        std::make_tuple("arm64", kArm64),
+        std::make_tuple("arm", kArm32),
+        std::make_tuple("armv7l", kArm32),
+        std::make_tuple("ppc", kPpc32),
+        std::make_tuple("ppc64", kPpc64),
+        std::make_tuple("ppc64le", kPpc64),
+        std::make_tuple("s390x", kS390x),
+        std::make_tuple("i386", kX86),
+        std::make_tuple("i486", kX86),
+        std::make_tuple("i586", kX86),
+        std::make_tuple("i686", kX86),
+        std::make_tuple("x86", kX86),
+        std::make_tuple("i86pc", kX86),
+        std::make_tuple("x86pc", kX86),
+        std::make_tuple("ia64", kIa64),
         std::make_tuple("UNKNOWN", "UNKNOWN")
     )
 );
diff --git a/test/os_utils/get_os_type.cpp b/test/os_utils/get_os_type.cpp
index 4a58c87..9f034cf 100644
--- a/test/os_utils/get_os_type.cpp
+++ b/test/os_utils/get_os_type.cpp
@@ -1,12 +1,25 @@
 #include <tuple>
 
 #include <gtest/gtest.h>
-#include <opentelemetry/sdk/resource/semantic_conventions.h>
+
+#include <opentelemetry/version.h>
+
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+#    include <opentelemetry/sdk/resource/semantic_conventions.h>
+#else
+#    include <opentelemetry/semconv/incubating/os_attributes.h>
+#endif
 
 #include "os_utils.h"
 
 class GetOsTypeTest : public testing::TestWithParam<std::tuple<std::string, std::string>> {};
 
+#if OPENTELEMETRY_VERSION_MAJOR == 1 && OPENTELEMETRY_VERSION_MINOR < 18
+using namespace ::opentelemetry::sdk::resource::SemanticConventions::OsTypeValues;
+#else
+using namespace ::opentelemetry::semconv::os::OsTypeValues;
+#endif
+
 TEST_P(GetOsTypeTest, get_os_type)
 {
     std::string input;
@@ -21,27 +34,25 @@ INSTANTIATE_TEST_SUITE_P(
     Table,
     GetOsTypeTest,
     testing::Values(
-        std::make_tuple("Linux", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kLinux),
-        std::make_tuple("Windows_NT", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows),
-        std::make_tuple("CYGWIN_NT-5.1", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows),
-        std::make_tuple("CYGWIN_NT-6.1", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows),
-        std::make_tuple(
-            "CYGWIN_NT-6.1-WOW64", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows
-        ),
-        std::make_tuple("CYGWIN_NT-10.0", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows),
-        std::make_tuple("MINGW32_NT-6.1", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows),
-        std::make_tuple("MSYS_NT-6.1", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows),
-        std::make_tuple("MINGW32_NT-10.0", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows),
-        std::make_tuple("MSYS_NT-10.0", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kWindows),
-        std::make_tuple("DragonFly", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kDragonflybsd),
-        std::make_tuple("FreeBSD", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kFreebsd),
-        std::make_tuple("HP-UX", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kHpux),
-        std::make_tuple("AIX", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kAix),
-        std::make_tuple("Darwin", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kDarwin),
-        std::make_tuple("NetBSD", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kNetbsd),
-        std::make_tuple("OpenBSD", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kOpenbsd),
-        std::make_tuple("SunOS", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kSolaris),
-        std::make_tuple("OS/390", opentelemetry::sdk::resource::SemanticConventions::OsTypeValues::kZOs),
+        std::make_tuple("Linux", kLinux),
+        std::make_tuple("Windows_NT", kWindows),
+        std::make_tuple("CYGWIN_NT-5.1", kWindows),
+        std::make_tuple("CYGWIN_NT-6.1", kWindows),
+        std::make_tuple("CYGWIN_NT-6.1-WOW64", kWindows),
+        std::make_tuple("CYGWIN_NT-10.0", kWindows),
+        std::make_tuple("MINGW32_NT-6.1", kWindows),
+        std::make_tuple("MSYS_NT-6.1", kWindows),
+        std::make_tuple("MINGW32_NT-10.0", kWindows),
+        std::make_tuple("MSYS_NT-10.0", kWindows),
+        std::make_tuple("DragonFly", kDragonflybsd),
+        std::make_tuple("FreeBSD", kFreebsd),
+        std::make_tuple("HP-UX", kHpux),
+        std::make_tuple("AIX", kAix),
+        std::make_tuple("Darwin", kDarwin),
+        std::make_tuple("NetBSD", kNetbsd),
+        std::make_tuple("OpenBSD", kOpenbsd),
+        std::make_tuple("SunOS", kSolaris),
+        std::make_tuple("OS/390", kZOs),
         std::make_tuple("UNKNOWN", "UNKNOWN")
     )
 );