Allow an isolate to have a simple random uuid

src/workerd/jsg/jsg-test.c++

@@ -359,4 +359,21 @@ KJ_TEST("Test JSG_CALLABLE") {
 }
 
 }  // namespace
+
+// ========================================================================================
+
+struct IsolateUuidContext: public Object {
+  JSG_RESOURCE_TYPE(IsolateUuidContext) {}
+};
+JSG_DECLARE_ISOLATE_TYPE(IsolateUuidIsolate, IsolateUuidContext);
+
+KJ_TEST("jsg::Lock getUuid") {
+  IsolateUuidIsolate isolate(v8System);
+  IsolateUuidIsolate::Lock lock(isolate);
+  // Returns the same value
+  KJ_ASSERT(lock.getUuid() == lock.getUuid());
+  KJ_ASSERT(isolate.getUuid() == lock.getUuid());
+  KJ_ASSERT(lock.getUuid().size() == 36);
+}
+
 }  // namespace workerd::jsg::test

src/workerd/jsg/jsg.c++

@@ -173,6 +173,10 @@ void Lock::requestGcForTesting() const {
     v8::Isolate::GarbageCollectionType::kFullGarbageCollection);
 }
 
+kj::StringPtr Lock::getUuid() const {
+  return IsolateBase::from(v8Isolate).getUuid();
+}
+
 v8::Local<v8::Private> Lock::getPrivateSymbolFor(Lock::PrivateSymbols symbol) {
   return IsolateBase::from(v8Isolate).getPrivateSymbolFor(symbol);
 }

src/workerd/jsg/jsg.h

@@ -2017,6 +2017,10 @@ class Lock {
   // it will throw. If a need for a minor GC is needed look at the call in jsg.c++ and the
   // implementation in setup.c++. Use responsibly.
 
+  kj::StringPtr getUuid() const;
+  // Returns a random UUID for this isolate instance. This is largely intended for logging and
+  // diagnostic purposes.
+
 #define V(name, _) name,
   enum PrivateSymbols {
     JSG_PRIVATE_SYMBOLS(V)

src/workerd/jsg/setup.c++

@@ -9,6 +9,7 @@
 
 #include "setup.h"
 #include "async-context.h"
+#include <workerd/util/uuid.h>
 #include <cxxabi.h>
 #include "libplatform/libplatform.h"
 #include <ucontext.h>
@@ -641,4 +642,10 @@ kj::Maybe<kj::StringPtr> getJsStackTrace(void* ucontext, kj::ArrayPtr<char> scra
   return kj::StringPtr(scratch.begin(), pos - scratch.begin());
 }
 
+kj::StringPtr IsolateBase::getUuid() {
+  // Lazily create a random UUID for this isolate.
+  KJ_IF_MAYBE(u, uuid) { return *u; }
+  return uuid.emplace(randomUUID(nullptr));
+}
+
 }  // namespace workerd::jsg

src/workerd/jsg/setup.h

@@ -106,6 +106,9 @@ class IsolateBase {
 
   v8::Local<v8::Private> getPrivateSymbolFor(Lock::PrivateSymbols symbol);
 
+  kj::StringPtr getUuid();
+  // Returns a random UUID for this isolate instance.
+
 private:
   template <typename TypeWrapper>
   friend class Isolate;
@@ -136,6 +139,7 @@ class IsolateBase {
 
   const V8System& system;
   v8::Isolate* ptr;
+  kj::Maybe<kj::String> uuid;
   bool evalAllowed = false;
   bool captureThrowsAsRejections = false;
   // The Web Platform API specifications require that any API that returns a JavaScript Promise