@superblocksteam/sdk 2.0.6 → 2.0.7

package/src/cli-replacement/dev.mts

@@ -1,7 +1,6 @@
 import "../dev-utils/dev-tracer.js";
 
 import * as child_process from "node:child_process";
-import * as fsp from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { maskUnixSignals } from "@superblocksteam/util";
@@ -18,15 +17,16 @@ import fs from "fs-extra";
 import { resolveCommand } from "package-manager-detector";
 import { detect } from "package-manager-detector/detect";
 
-import { getLogger } from "../dev-utils/dev-logger.mjs";
+import { getErrorMeta, getLogger } from "../dev-utils/dev-logger.mjs";
 import { createDevServer } from "../dev-utils/dev-server.mjs";
-import tracer from "../dev-utils/dev-tracer.js";
+import tracer, { initializeTracingSdk } from "../dev-utils/dev-tracer.js";
 import { SuperblocksSdk } from "../sdk.js";
 import {
   checkVersionsAndUpgrade,
   getCurrentCliVersion,
   getCurrentLibraryVersionWithoutPM,
 } from "./automatic-upgrades.js";
+import { AUTO_UPGRADE_EXIT_CODE } from "./automatic-upgrades.js";
 import type { DevLogger } from "../dev-utils/dev-logger.mjs";
 import type { ApplicationConfig } from "../types/common.js";
 import type { DraftInterface } from "@superblocksteam/vite-plugin-file-sync/draft-interface";
@@ -93,7 +93,6 @@ async function installPackages(cwd: string, logger: DevLogger) {
 export async function dev(options: {
   /* cwd is required */
   cwd: string;
-  pidfilePath?: string;
   devServerPort?: number;
 
   /* user control of sync operations */
@@ -107,7 +106,7 @@ export async function dev(options: {
   /* For debugging purposes to get location of the cli */
   superblocksPath?: string;
   /* For redirecting output, like when running outside of the CLI */
-  logger?: (message: string) => void;
+  logger?: (...messages: (string | Error)[]) => void;
 
   /* For a child process when restarting the dev server for automatic upgrades */
   skipAutoUpgrade?: boolean;
@@ -119,7 +118,6 @@ export async function dev(options: {
 
   const {
     cwd,
-    pidfilePath,
     devServerPort,
     downloadFirst,
     uploadFirst,
@@ -127,12 +125,7 @@ export async function dev(options: {
     applicationConfig,
     skipAutoUpgrade,
   } = options;
-
-  const cliVersion = await getCurrentCliVersion();
-  const libraryVersion = await getCurrentLibraryVersionWithoutPM();
-  logger.info(
-    `Running command: ${options.superblocksPath} dev${options.uploadFirst ? " --upload-first" : ""}${options.downloadFirst ? " --download-first" : ""} with baseUrl: ${applicationConfig?.superblocksBaseUrl}, cliVersion: ${cliVersion}, libraryVersion: ${libraryVersion?.alias} ${libraryVersion?.version}`,
-  );
+  initializeTracingSdk(applicationConfig);
 
   // Add check for node_modules
   if (!fs.existsSync(path.join(cwd, "node_modules"))) {
@@ -141,9 +134,13 @@ export async function dev(options: {
     );
   }
 
-  if (pidfilePath) {
-    await fsp.writeFile(pidfilePath, `${process.pid}\n`);
-  }
+  logger.info("Starting dev server");
+
+  const cliVersion = await getCurrentCliVersion();
+  const libraryVersion = await getCurrentLibraryVersionWithoutPM();
+  logger.info(
+    `Running command: ${options.superblocksPath} dev${options.uploadFirst ? " --upload-first" : ""}${options.downloadFirst ? " --download-first" : ""} with baseUrl: ${applicationConfig?.superblocksBaseUrl}, cliVersion: ${cliVersion?.alias} ${cliVersion?.version}, libraryVersion: ${libraryVersion?.alias} ${libraryVersion?.version}`,
+  );
 
   const port = devServerPort ?? 5173;
 
@@ -188,17 +185,11 @@ export async function dev(options: {
         if (lockService) {
           try {
             await lockService!.acquireLock();
-
-            // TODO(code-mode): package naming is preventing upgrade in ephemeral environments
-            if (
-              !process.env.PACKAGE_SUFFIX ||
-              process.env.PACKAGE_SUFFIX === "" ||
-              !skipAutoUpgrade
-            ) {
-              await checkVersionsAndUpgrade(lockService, applicationConfig);
-            }
           } catch (error) {
-            logger.error("Failed to acquire lock on application", error);
+            logger.error(
+              "Failed to acquire lock on application",
+              getErrorMeta(error),
+            );
             passErrorToVSCode(
               (error as { context?: { message: string } }).context?.message,
               logger,
@@ -222,7 +213,6 @@ export async function dev(options: {
           appRootDirPath: options.cwd,
           applicationId: applicationConfig.id,
           organizationId: currentUser.organizations[0].id,
-          anthropicApiKey: process.env.ANTHROPIC_API_KEY || "",
           fsOperationQueue,
           draftInterface: syncService! as DraftInterface,
           tracer,
@@ -231,12 +221,15 @@ export async function dev(options: {
         const isSynced = localContents.hash === serverHash;
 
         if (isSynced) {
-          logger.info("Local files are in sync with the server");
-          return;
+          logger.info(
+            `Local files are in sync with the server on branch '${applicationConfig.branchName}'`,
+          );
+        } else {
+          logger.info(
+            `Local files are out of sync with the server on branch '${applicationConfig.branchName}'`,
+          );
         }
 
-        logger.info("Local files are out of sync with the server");
-
         if (!(downloadFirst || uploadFirst)) {
           throw new Error(
             "You must choose --download-first or --upload-first to use the dev command",
@@ -246,37 +239,74 @@ export async function dev(options: {
           throw new Error("Choose either --download-first or --upload-first");
         }
 
+        let hasPackageChanged = false;
+
         if (downloadFirst) {
           logger.info(
-            "Starting directory sync from server before starting the local server",
+            `Starting download of branch '${applicationConfig.branchName}'`,
           );
 
-          // Read package.json before download
           const packageJsonBefore = await readPkgJson(cwd);
-
           await syncService!.downloadDirectory();
-
-          // Read package.json after download and compare
           const packageJsonAfter = await readPkgJson(cwd);
 
-          // Check if package.json changed
           if (packageJsonBefore && packageJsonAfter) {
             const diff = diffJson(packageJsonBefore, packageJsonAfter);
-            const hasChanges = diff.some((part) => part.added || part.removed);
+            hasPackageChanged = diff.some((part) => part.added || part.removed);
+          } else if (packageJsonAfter) {
+            hasPackageChanged = true;
+            logger.info("package.json was created, installing packages…");
+          }
+        }
 
-            if (hasChanges) {
-              logger.info("package.json has changed, installing packages…");
-              await installPackages(cwd, logger);
+        let hasCliUpdated = false;
+        if (
+          !process.env.PACKAGE_SUFFIX ||
+          process.env.PACKAGE_SUFFIX === "" ||
+          !skipAutoUpgrade
+        ) {
+          if (lockService) {
+            const result = await checkVersionsAndUpgrade(
+              lockService,
+              applicationConfig,
+            );
+            if (result?.libraryUpdated) {
+              hasPackageChanged = true;
             }
+            hasCliUpdated = result?.cliUpdated ?? false;
+          } else {
+            logger.warn(
+              "Lock service is not available, skipping version check and upgrade",
+            );
           }
-        } else if (uploadFirst) {
-          logger.info("Uploading local files to server before starting");
+        }
+
+        if (hasPackageChanged) {
+          logger.info("Installing packages…");
+          await installPackages(cwd, logger);
+        }
+
+        if (hasPackageChanged || uploadFirst) {
+          logger.info(
+            `Uploading local files to branch '${applicationConfig.branchName}' on server before starting`,
+          );
           await syncService!.uploadDirectory();
+          await syncService!.uploadDirectoryNowIfNeeded();
+        }
+
+        if (hasCliUpdated) {
+          logger.info("CLI was updated, restarting the dev server…");
+          process.exit(AUTO_UPGRADE_EXIT_CODE);
         }
       });
     } catch (error: any) {
       logger.error(error.message);
-      process.exit(1);
+      try {
+        await lockService?.shutdownAndExit();
+      } finally {
+        // this is redundant, but it's here to make sure the lock service is shutdown and the process exits
+        process.exit(1);
+      }
     }
   } else {
     logger.info("Skipping directory sync");
@@ -296,6 +326,10 @@ export async function dev(options: {
   options.signal?.addEventListener("abort", () => {
     logger.info("Server closed");
     httpServer.close();
+    lockService?.shutdownAndExit().catch(() => {
+      // this is redundant, but it's here to make sure the lock service is shutdown and the process exits
+      process.exit(1);
+    });
   });
 
   logger.debug(green(`Local server started at port ${port}`));

package/src/client.ts

@@ -11,6 +11,7 @@ import {
   NotFoundError,
   BadRequestError,
   unreachable,
+  getSuperblocksDevEnvironmentConfigJson,
 } from "@superblocksteam/util";
 import axios, { AxiosError } from "axios";
 import FormData from "form-data";
@@ -24,6 +25,10 @@ import { signingEnabled } from "./flag.js";
 import { connectToISocketRPCServer } from "./socket/index.js";
 import { AgentType } from "./types/index.js";
 import { getAgentUrl } from "./utils.js";
+import {
+  DEFAULT_BRANCH,
+  getCurrentGitBranchIfGit,
+} from "./version-control.mjs";
 import type { StdISocketRPCClient } from "./socket/index.js";
 import type {
   ApiWithPb,
@@ -133,6 +138,116 @@ enum ResourceType {
   BACKEND = "BACKEND",
 }
 
+export enum BranchSource {
+  DEV_ENVIRONMENT = "dev environment config file",
+  COMMAND_LINE = "command line",
+  GIT_REPO = "current git repository",
+  DEFAULT = "default",
+}
+
+export class CurrentBranch {
+  public readonly branchName: string;
+  public readonly source: BranchSource;
+  public readonly sourcePath?: string;
+  public readonly userSpecifiedBranch?: string;
+
+  constructor({
+    branchName,
+    source,
+    sourcePath,
+    userSpecifiedBranch,
+  }: {
+    branchName: string;
+    source: BranchSource;
+    sourcePath?: string;
+    userSpecifiedBranch?: string;
+  }) {
+    this.branchName = branchName;
+    this.source = source;
+    this.sourcePath = sourcePath;
+    this.userSpecifiedBranch = userSpecifiedBranch;
+  }
+  isDevEnvironmentWithUserSpecifiedBranch() {
+    return (
+      this.isDefinedInDevEnvironmentConfig() &&
+      this.userSpecifiedBranch !== undefined
+    );
+  }
+  isDefinedInDevEnvironmentConfig(): boolean {
+    return this.source === BranchSource.DEV_ENVIRONMENT;
+  }
+  isDefaultBranch(): boolean {
+    return this.source === BranchSource.DEFAULT;
+  }
+  isGitBranch(): boolean {
+    return this.source === BranchSource.GIT_REPO;
+  }
+}
+
+const DEFAULT_BRANCH_INFO = new CurrentBranch({
+  branchName: DEFAULT_BRANCH,
+  source: BranchSource.DEFAULT,
+});
+
+// TODO (randall): Remove this and the 'index.ts' export when it is no longer needed in the CLI.
+export function getDefaultBranchInfo(): CurrentBranch {
+  return DEFAULT_BRANCH_INFO;
+}
+
+/**
+ * Returns the current branch name, in the following order of precedence:
+ * 1. If a branch name is specified in the dev environment config, use that
+ * 2. If a branch name is specified, use that
+ * 3. If this is in a git repo, use the current branch
+ * 4. If this is not in a git repo, use the default branch
+ * @param userSpecifiedBranch - The branch name specified by the user
+ * @param pathPrefix - The path prefix to use when looking for the dev environment config
+ * @returns The current branch information
+ */
+export async function getCurrentBranchInfo(
+  userSpecifiedBranch?: string,
+  pathPrefix?: string,
+): Promise<CurrentBranch> {
+  // First, if there is a dev environment config and a branch name is specified, use that
+  try {
+    const [devEnvironmentConfig, devEnvConfigPath] =
+      await getSuperblocksDevEnvironmentConfigJson(true, pathPrefix);
+    if (devEnvironmentConfig.branch) {
+      return new CurrentBranch({
+        branchName: devEnvironmentConfig.branch,
+        source: BranchSource.DEV_ENVIRONMENT,
+        sourcePath: devEnvConfigPath,
+        userSpecifiedBranch: userSpecifiedBranch,
+      });
+    }
+  } catch {
+    // Did not find or could not parse the dev environment config, so continue
+  }
+  // Second, if the user specified a branch name, use that
+  if (userSpecifiedBranch) {
+    return new CurrentBranch({
+      branchName: userSpecifiedBranch,
+      source: BranchSource.COMMAND_LINE,
+      userSpecifiedBranch: userSpecifiedBranch,
+    });
+  }
+  // Third, if this is in a git repo, use the current branch
+  const currentGitBranch = await getCurrentGitBranchIfGit();
+  if (currentGitBranch) {
+    return new CurrentBranch({
+      branchName: currentGitBranch,
+      source: BranchSource.GIT_REPO,
+      userSpecifiedBranch: userSpecifiedBranch,
+    });
+  }
+  // Fourth, if this is not in a git repo, use the default branch
+  return new CurrentBranch({
+    branchName: DEFAULT_BRANCH,
+    source: BranchSource.DEFAULT,
+    userSpecifiedBranch: userSpecifiedBranch,
+  });
+}
+
 export async function fetchApplication({
   cliVersion,
   applicationId,

package/src/dev-utils/dev-logger.mts

@@ -1,39 +1,113 @@
 import { createLogger, format, transports } from "winston";
+import type winston from "winston";
 
-export type DevLogger = {
-  debug: (message: string, ...meta: any[]) => void;
-  info: (message: string, ...meta: any[]) => void;
-  warn: (message: string, ...meta: any[]) => void;
-  error: (message: string, ...meta: any[]) => void;
-};
+const activeTransports: winston.transport[] = [];
+
+if (process.env.SUPERBLOCKS_IS_CSB === "true") {
+  activeTransports.push(
+    new transports.File({
+      format: format.json(),
+      filename: `/tmp/dev-server.log`,
+      level: "info",
+    }),
+  );
+}
+
+activeTransports.push(
+  new transports.Console({
+    format: format.combine(
+      format.colorize(),
+      format.timestamp({
+        format: "HH:mm:ss.SSS",
+      }),
+      format.printf((props) => {
+        const { message, timestamp, error, level } = props;
+        const base =
+          process.env.SUPERBLOCKS_IS_CSB === "true"
+            ? `${timestamp} ${message}`
+            : `${message}`;
+        if (level === "error") {
+          return `${base} ${(error as ErrorMeta["error"]).message} ${(error as ErrorMeta["error"]).stack}`;
+        }
+        return base;
+      }),
+    ),
+  }),
+);
 
 const winstonLogger = createLogger({
-  level: "info",
+  level: "debug",
   exitOnError: false,
   format: format.json(),
-  transports: [
-    new transports.File({ filename: `/tmp/dev-server.log`, level: "info" }),
-    new transports.Console({
-      format: format.combine(
-        format.printf(({ message }) => `${message}`),
-        format.colorize({ message: true }),
-      ),
-      level: "debug",
-    }),
-  ],
+  transports: activeTransports,
+});
+
+interface ErrorMeta {
+  error: {
+    kind: string;
+    message: string;
+    stack?: string;
+  };
+}
+
+export interface DevLogger {
+  log: (...messages: string[]) => void;
+  debug: (...messages: string[]) => void;
+  info: (...messages: string[]) => void;
+  warn: (...messages: string[]) => void;
+  error: (message: string, meta?: ErrorMeta) => void;
+}
+const logger: DevLogger = Object.freeze({
+  debug: (...messages: string[]) =>
+    winstonLogger.debug(
+      messages.length > 0 ? messages.join(" ") : (messages[0] as string),
+    ),
+  log: (...messages: string[]) =>
+    winstonLogger.info(
+      messages.length > 0 ? messages.join(" ") : (messages[0] as string),
+    ),
+  info: (...messages: string[]) =>
+    winstonLogger.info(
+      messages.length > 0 ? messages.join(" ") : (messages[0] as string),
+    ),
+  warn: (...messages: string[]) =>
+    winstonLogger.warn(
+      messages.length > 0 ? messages.join(" ") : (messages[0] as string),
+    ),
+  error: (message: string, meta?: ErrorMeta) =>
+    winstonLogger.error(message, meta),
 });
 
 export function getLogger(
-  loggerOverride?: (message: string) => void,
+  loggerOverride?: (...messages: string[]) => void,
 ): DevLogger {
   if (!loggerOverride) {
-    return winstonLogger;
+    return logger;
   }
 
   return {
     debug: loggerOverride,
     info: loggerOverride,
     warn: loggerOverride,
-    error: loggerOverride,
+    log: loggerOverride,
+    error: loggerOverride as any,
+  };
+}
+
+export function getErrorMeta(error: unknown): ErrorMeta {
+  if (error instanceof Error) {
+    return {
+      error: {
+        kind: error.name,
+        message: error.message,
+        stack: error.stack,
+      },
+    };
+  }
+  return {
+    error: {
+      kind: "Unknown Error",
+      message: JSON.stringify(error),
+    },
   };
 }

package/src/dev-utils/dev-server.mts

@@ -18,7 +18,8 @@ import {
   customComponentsPlugin,
   isCustomComponentsEnabled,
 } from "./custom-build.mjs";
-import { getLogger } from "./dev-logger.mjs";
+import { getErrorMeta, getLogger } from "./dev-logger.mjs";
+import { buildManifestStubPlugin } from "./vite-plugin-build-manifest-stub.mjs";
 import { ddRumPlugin } from "./vite-plugin-dd-rum.mjs";
 import { superblocksCdnPlugin } from "./vite-plugin-sb-cdn.mjs";
 import type { AiService } from "@superblocksteam/vite-plugin-file-sync/ai-service";
@@ -187,13 +188,6 @@ export async function createDevServer({
     }, viteReject);
   });
 
-  // TODO(code-mode): remove this soon
-  app.get("/_sb_disconnect", async (_req, res) => {
-    console.log("GET /_sb_disconnect");
-    // TODO(code-mode): should this include any validation checks, such as getting a token?
-    await gracefulShutdown({ logger, serverInitiated: false });
-    res.send("ok");
-  });
   app.post("/_sb_disconnect", async (req, res) => {
     const { initiatedByEmail, switchingTo } = req.body;
     // TODO(code-mode): should this include any validation checks, such as getting a token?
@@ -206,7 +200,7 @@ export async function createDevServer({
       });
       res.send("ok");
     } catch (e) {
-      console.error("Error disconnecting from dev server", e);
+      logger.error("Error disconnecting from dev server", getErrorMeta(e));
       res.status(500).send("Error disconnecting from dev server");
     }
   });
@@ -260,7 +254,7 @@ async function startVite({
 }) {
   const viteLogger = createLogger();
   const logger = getLogger(loggerOverride);
-  viteLogger.info = logger.info;
+  viteLogger.info = (msg: string) => logger.info(msg);
   viteLogger.warn = (msg: string) => {
     logger.warn(yellow(msg));
   };
@@ -276,6 +270,8 @@ async function startVite({
   const isCustomBuildEnabled = await isCustomComponentsEnabled();
   const customFolder = path.join(root, "custom");
 
+  const draftsFolder = path.join(root, ".superblocks");
+
   const cdnUrl = process.env.SUPERBLOCKS_CDN_URL ?? "http://localhost:4040/cdn";
 
   const env = loadEnv(mode, root, "");
@@ -313,7 +309,7 @@ async function startVite({
     server: {
       middlewareMode: true,
       watch: {
-        ignored: [`${customFolder}/**/*`],
+        ignored: [`${customFolder}/**/*`, `${draftsFolder}/**/*`],
       },
       hmr: hmrOptions,
       cors: {
@@ -342,11 +338,13 @@ async function startVite({
           aiService,
           httpServer,
           tracer,
-          logger,
         },
         { isCustomBuildEnabled },
       ) as Plugin,
 
+      // Add a virtual "stub" module for the build manifest
+      buildManifestStubPlugin(),
+
       // for now, only use the CDN locally
       superblocksCdnPlugin({
         imports: {

package/src/dev-utils/dev-tracer.ts

@@ -6,8 +6,13 @@ import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
 import { Resource } from "@opentelemetry/resources";
 import { NodeSDK } from "@opentelemetry/sdk-node";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import {
+  OBS_TAG_APPLICATION_ID,
+  OBS_TAG_BRANCH,
+} from "@superblocksteam/shared";
 import { getLocalTokenWithUrl } from "@superblocksteam/util";
 import packageJson from "../../package.json" with { type: "json" };
+import type { ApplicationConfig } from "../types/index.js";
 import type { Span } from "@opentelemetry/api";
 
 // NOTE: @joeyagreco - this is how the "env" facet is determined in datadog: https://docs.datadoghq.com/opentelemetry/setup/collector_exporter/#3---configure-your-application
@@ -15,6 +20,7 @@ const ATTR_DEPLOYMENT_ENVIRONMENT = "deployment.environment";
 // NOTE: @joeyagreco - this can be used to determine if we are using mock-csb, staging-csb, prod-csb, etc
 const ATTR_SUPERBLOCKS_BASE_URL = "superblocks.base_url";
 const ATTR_SUPERBLOCKS_CLI_TOKEN = "superblocks.cli_token";
+const ATTR_SUPERBLOCKS_IS_CSB = "superblocks.is_csb";
 let superblocksTracesUrl = undefined;
 let superblocksHostname = "unknown";
 let token = "unknown";
@@ -30,45 +36,50 @@ try {
   console.error("[tracing init] could not determine superblocks base url", e);
 }
 
-// Initialize the OpenTelemetry SDK
-const sdk = new NodeSDK({
-  resource: Resource.default().merge(
-    new Resource({
-      [ATTR_SERVICE_NAME]: "sdk-dev-server",
-      [ATTR_DEPLOYMENT_ENVIRONMENT]: process.env.SUPERBLOCKS_CLI_ENV,
-      [ATTR_SUPERBLOCKS_BASE_URL]: superblocksHostname,
-      [ATTR_SUPERBLOCKS_CLI_TOKEN]: token,
+export const initializeTracingSdk = (applicationConfig?: ApplicationConfig) => {
+  // Initialize the OpenTelemetry SDK
+  const sdk = new NodeSDK({
+    resource: Resource.default().merge(
+      new Resource({
+        [ATTR_SERVICE_NAME]: "sdk-dev-server",
+        [ATTR_DEPLOYMENT_ENVIRONMENT]: process.env.SUPERBLOCKS_CLI_ENV,
+        [ATTR_SUPERBLOCKS_BASE_URL]: superblocksHostname,
+        [ATTR_SUPERBLOCKS_CLI_TOKEN]: token,
+        [OBS_TAG_APPLICATION_ID]: applicationConfig?.id,
+        [OBS_TAG_BRANCH]: applicationConfig?.branchName,
+        [ATTR_SUPERBLOCKS_IS_CSB]: process.env.SUPERBLOCKS_IS_CSB,
+      }),
+    ),
+    traceExporter: new OTLPTraceExporter({
+      url: superblocksTracesUrl, // OTLPTraceExporter defaults to sending traffic to http://localhost:4318/v1/traces
     }),
-  ),
-  traceExporter: new OTLPTraceExporter({
-    url: superblocksTracesUrl, // OTLPTraceExporter defaults to sending traffic to http://localhost:4318/v1/traces
-  }),
-  contextManager: new AsyncLocalStorageContextManager(),
-  instrumentations: [
-    // Configure HTTP instrumentation with custom attributes
-    new HttpInstrumentation({
-      requestHook: (span: Span, request: any) => {
-        let resource = "GET";
-        if (request) {
-          resource = `${request.method} ${request.url || request.path}`;
-        }
-        span.setAttributes({
-          "resource.name": resource,
-        });
-      },
-    }),
-    // Configure Express instrumentation
-    new ExpressInstrumentation({
-      requestHook: (span: Span, request: any) => {
-        span.setAttributes({
-          "resource.name": `${request.method} ${request.url}`,
-        });
-      },
-    }),
-  ],
-});
+    contextManager: new AsyncLocalStorageContextManager(),
+    instrumentations: [
+      // Configure HTTP instrumentation with custom attributes
+      new HttpInstrumentation({
+        requestHook: (span: Span, request: any) => {
+          let resource = "GET";
+          if (request) {
+            resource = `${request.method} ${request.url || request.path}`;
+          }
+          span.setAttributes({
+            "resource.name": resource,
+          });
+        },
+      }),
+      // Configure Express instrumentation
+      new ExpressInstrumentation({
+        requestHook: (span: Span, request: any) => {
+          span.setAttributes({
+            "resource.name": `${request.method} ${request.url}`,
+          });
+        },
+      }),
+    ],
+  });
 
-sdk.start();
+  sdk.start();
+};
 
 // Get a tracer instance
 const tracer = trace.getTracer("sdk-dev-server", packageJson.version);