feat: queue time metric

app/[[...path]]/page.tsx

@@ -131,14 +131,29 @@ export default async function Page(props: {params: Promise<{path?: string[]}>})
     }
     const {mdxSource, frontMatter} = doc;
 
+    // Fetch git metadata on-demand for this page only (faster in dev mode)
+    let gitMetadata = pageNode.frontmatter.gitMetadata;
+    if (!gitMetadata && pageNode.frontmatter.sourcePath?.startsWith('develop-docs/')) {
+      // In dev mode or if not cached, fetch git metadata for current page only
+      const {getGitMetadata} = await import('sentry-docs/utils/getGitMetadata');
+      const metadata = getGitMetadata(pageNode.frontmatter.sourcePath);
+      gitMetadata = metadata ?? undefined;
+    }
+
+    // Merge gitMetadata into frontMatter
+    const frontMatterWithGit = {
+      ...frontMatter,
+      gitMetadata,
+    };
+
     // pass frontmatter tree into sidebar, rendered page + fm into middle, headers into toc
     const pageType = (params.path?.[0] as PageType) || 'unknown';
     return (
       <Fragment>
         <PageLoadMetrics pageType={pageType} attributes={{is_developer_docs: true}} />
         <MDXLayoutRenderer
           mdxSource={mdxSource}
-          frontMatter={frontMatter}
+          frontMatter={frontMatterWithGit}
           nextPage={nextPage}
           previousPage={previousPage}
         />

docs/platforms/ruby/common/configuration/options.mdx

@@ -326,6 +326,32 @@ config.trace_ignore_status_codes = [404, (502..511)]
 
 </SdkOption>
 
+<SdkOption name="capture_queue_time" type="Boolean" defaultValue="true">
+
+Automatically capture how long requests wait in the web server queue before processing begins. The SDK reads the `X-Request-Start` header set by reverse proxies (Nginx, HAProxy, Heroku) and attaches queue time to transactions as `http.queue_time_ms`.
+
+This helps identify when requests are delayed due to insufficient worker threads or server capacity, which is especially useful under load.
+
+To disable queue time capture:
+
+```ruby
+config.capture_queue_time = false
+```
+
+**Nginx:**
+
+```nginx
+proxy_set_header X-Request-Start "t=${msec}";
+```
+
+**HAProxy:**
+
+```haproxy
+http-request set-header X-Request-Start t=%Ts%ms
+```
+
+</SdkOption>
+
 <SdkOption name="instrumenter" type="Symbol" defaultValue=":sentry">
 
 The instrumenter to use, `:sentry` or `:otel` for [use with OpenTelemetry](../../tracing/instrumentation/opentelemetry).

docs/platforms/ruby/common/tracing/instrumentation/automatic-instrumentation.mdx

@@ -20,5 +20,7 @@ Spans are instrumented for the following operations within a transaction:
   - includes common database systems such as Postgres and MySQL
 - Outgoing HTTP requests made with `Net::HTTP`
 - Redis operations
+- Queue time for requests behind reverse proxies (Nginx, HAProxy, Heroku)
+  - Requires `X-Request-Start` header from reverse proxy
 
 Spans are only created within an existing transaction. If you're not using any of the supported frameworks, you'll need to <PlatformLink to="/tracing/instrumentation/custom-instrumentation/">create transactions manually</PlatformLink>.

docs/platforms/ruby/common/tracing/instrumentation/performance-metrics.mdx

@@ -22,6 +22,8 @@ Sentry supports adding arbitrary custom units, but we recommend using one of the
 
 <Include name="custom-measurements-units-disclaimer.mdx" />
 
+<PlatformContent includePath="performance/queue-time-capture" />
+
 ## Supported Measurement Units
 
 Units augment measurement values by giving meaning to what otherwise might be abstract numbers. Adding units also allows Sentry to offer controls - unit conversions, filters, and so on - based on those units. For values that are unitless, you can supply an empty string or `none`.

platform-includes/performance/queue-time-capture/ruby.mdx

@@ -0,0 +1,50 @@
+## Automatic Queue Time Capture
+
+The Ruby SDK automatically captures queue time for Rack-based applications when the `X-Request-Start` header is present. This measures how long requests wait in the web server queue (e.g., waiting for a Puma thread) before your application begins processing them.
+
+Queue time is attached to transactions as `http.queue_time_ms` and helps identify server capacity issues.
+
+### Setup
+
+Configure your reverse proxy to add the `X-Request-Start` header:
+
+**Nginx:**
+
+```nginx
+location / {
+  proxy_pass http://your-app;
+  proxy_set_header X-Request-Start "t=${msec}";
+}
+```
+
+**HAProxy:**
+
+```haproxy
+frontend http-in
+  http-request set-header X-Request-Start t=%Ts%ms
+```
+
+**Heroku:** The header is automatically set by Heroku's router.
+
+### How It Works
+
+The SDK:
+
+1. Reads the `X-Request-Start` header timestamp from your reverse proxy
+2. Calculates the time difference between the header timestamp and when the request reaches your application
+3. Subtracts `puma.request_body_wait` (if present) to exclude time spent waiting for slow client uploads
+4. Attaches the result as `http.queue_time_ms` to the transaction
+
+### Disable Queue Time Capture
+
+If you don't want queue time captured, disable it in your configuration:
+
+```ruby
+Sentry.init do |config|
+  config.capture_queue_time = false
+end
+```
+
+### Viewing Queue Time
+
+Queue time appears in the Sentry transaction details under the "Data" section as `http.queue_time_ms` (measured in milliseconds).

src/components/docPage/index.tsx

@@ -16,6 +16,7 @@ import {CopyMarkdownButton} from '../copyMarkdownButton';
 import {DocFeedback} from '../docFeedback';
 import {GitHubCTA} from '../githubCTA';
 import {Header} from '../header';
+import {LastUpdated} from '../lastUpdated';
 import Mermaid from '../mermaid';
 import {PaginationNav} from '../paginationNav';
 import {PlatformSdkDetail} from '../platformSdkDetail';
@@ -94,6 +95,10 @@ export function DocPage({
             <div>
               <hgroup>
                 <h1>{frontMatter.title}</h1>
+                {/* Show last updated info for develop-docs pages */}
+                {frontMatter.gitMetadata && (
+                  <LastUpdated gitMetadata={frontMatter.gitMetadata} />
+                )}
                 <h2>{frontMatter.description}</h2>
               </hgroup>
               {/* This exact id is important for Algolia indexing */}

src/components/lastUpdated/index.tsx

@@ -0,0 +1,101 @@
+'use client';
+
+import Link from 'next/link';
+
+interface GitMetadata {
+  author: string;
+  commitHash: string;
+  timestamp: number;
+}
+
+interface LastUpdatedProps {
+  gitMetadata: GitMetadata;
+}
+
+/**
+ * Format a timestamp as a relative time string (e.g., "2 days ago")
+ */
+function formatRelativeTime(timestamp: number): string {
+  const now = Date.now();
+  const diff = now - timestamp * 1000; // timestamp is in seconds
+  const seconds = Math.floor(diff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(days / 365);
+
+  if (years > 0) {
+    return years === 1 ? '1 year ago' : `${years} years ago`;
+  }
+  if (months > 0) {
+    return months === 1 ? '1 month ago' : `${months} months ago`;
+  }
+  if (days > 0) {
+    return days === 1 ? '1 day ago' : `${days} days ago`;
+  }
+  if (hours > 0) {
+    return hours === 1 ? '1 hour ago' : `${hours} hours ago`;
+  }
+  if (minutes > 0) {
+    return minutes === 1 ? '1 minute ago' : `${minutes} minutes ago`;
+  }
+  return 'just now';
+}
+
+/**
+ * Format a timestamp as a full date string for tooltip
+ */
+function formatFullDate(timestamp: number): string {
+  const date = new Date(timestamp * 1000);
+  return date.toLocaleString('en-US', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+  });
+}
+
+/**
+ * Abbreviate a commit hash to first 7 characters
+ */
+function abbreviateHash(hash: string): string {
+  return hash.substring(0, 7);
+}
+
+export function LastUpdated({gitMetadata}: LastUpdatedProps) {
+  const {commitHash, author, timestamp} = gitMetadata;
+  const relativeTime = formatRelativeTime(timestamp);
+  const fullDate = formatFullDate(timestamp);
+  const abbreviatedHash = abbreviateHash(commitHash);
+  const commitUrl = `https://github.com/getsentry/sentry-docs/commit/${commitHash}`;
+
+  return (
+    <div className="flex flex-wrap items-center gap-1 text-xs text-[var(--foreground-secondary)] mt-1 mb-4">
+      {/* Text content */}
+      <span className="flex flex-wrap items-center gap-1">
+        <span>updated by</span>
+        <span className="font-medium">{author}</span>
+        {/* Relative time with tooltip */}
+        <span title={fullDate} className="cursor-help">
+          {relativeTime}
+        </span>
+      </span>
+
+      {/* Commit link */}
+      <span className="flex items-center gap-1">
+        <span className="text-[var(--foreground-secondary)]">•</span>
+        <Link
+          href={commitUrl}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="hover:text-[var(--accent-purple)] underline"
+        >
+          #{abbreviatedHash}
+        </Link>
+      </span>
+    </div>
+  );
+}

src/mdx.ts

@@ -268,10 +268,31 @@
 
             const source = await readFile(file, 'utf8');
             const {data: frontmatter} = matter(source);
+            const sourcePath = path.join(folder, fileName);
+
+            // In production builds, fetch git metadata for develop-docs pages only
+            // In development, skip this and fetch on-demand per page (faster dev server startup)
+            let gitMetadata: typeof frontmatter.gitMetadata = undefined;
+            if (
+              process.env.NODE_ENV !== 'development' &&
+              sourcePath.startsWith('develop-docs/')
+            ) {
+              const {getGitMetadata} = await import('./utils/getGitMetadata');
+              const metadata = getGitMetadata(sourcePath);
+              // Ensure we create a completely new object to avoid any reference sharing
+              gitMetadata = metadata ? {...metadata} : undefined;
+
+              // Log during build to debug Vercel issues
+              if (process.env.CI || process.env.VERCEL) {
+                console.log(`[BUILD] Git metadata for ${sourcePath}:`, gitMetadata);
+              }
+            }
+
             return {
               ...(frontmatter as FrontMatter),
               slug: fileName.replace(/\/index.mdx?$/, '').replace(/\.mdx?$/, ''),
-              sourcePath: path.join(folder, fileName),
+              sourcePath,
+              gitMetadata,
             };
           },
           {concurrency: FILE_CONCURRENCY_LIMIT}

src/types/frontmatter.ts

@@ -35,15 +35,23 @@ export interface FrontMatter {
    */
   fullWidth?: boolean;
 
+  /**
+   * Git metadata for the last commit & author that modified this file
+   */
+  gitMetadata?: {
+    author: string;
+    commitHash: string;
+    timestamp: number;
+  };
   /**
    * A list of keywords for indexing with search.
    */
   keywords?: string[];
+
   /**
    * Set this to true to show a "new" badge next to the title in the sidebar
    */
   new?: boolean;
-
   /**
    * The next page in the bottom pagination navigation.
    */
@@ -53,6 +61,7 @@ export interface FrontMatter {
    * takes precedence over children when present
    */
   next_steps?: string[];
+
   /**
    * Set this to true to disable indexing (robots, algolia) of this content.
    */

src/utils/getGitMetadata.ts

@@ -0,0 +1,70 @@
+import {execSync} from 'child_process';
+import path from 'path';
+
+export interface GitMetadata {
+  author: string;
+  commitHash: string;
+  timestamp: number;
+}
+
+// Cache to avoid repeated git calls during build
+const gitMetadataCache = new Map<string, GitMetadata | null>();
+
+/**
+ * Get git metadata for a file
+ * @param filePath - Path to the file relative to the repository root
+ * @returns Git metadata or null if unavailable
+ */
+export function getGitMetadata(filePath: string): GitMetadata | null {
+  // Check cache first
+  if (gitMetadataCache.has(filePath)) {
+    const cached = gitMetadataCache.get(filePath);
+    // Return a NEW copy to avoid reference sharing
+    return cached ? {...cached} : null;
+  }
+
+  try {
+    // Get commit hash, author name, and timestamp
+    const logOutput = execSync(`git log -1 --format="%H|%an|%at" -- "${filePath}"`, {
+      encoding: 'utf8',
+      cwd: path.resolve(process.cwd()),
+      stdio: ['pipe', 'pipe', 'ignore'], // Suppress stderr
+    }).trim();
+
+    // Log for debugging on Vercel
+    if (process.env.CI || process.env.VERCEL) {
+      console.log(`[getGitMetadata] File: ${filePath} -> Output: ${logOutput}`);
+    }
+
+    if (!logOutput) {
+      // No commits found for this file
+      gitMetadataCache.set(filePath, null);
+      return null;
+    }
+
+    const [commitHash, author, timestampStr] = logOutput.split('|');
+    const timestamp = parseInt(timestampStr, 10);
+
+    // Create a fresh object for each call to avoid reference sharing
+    const metadata: GitMetadata = {
+      commitHash,
+      author,
+      timestamp,
+    };
+
+    // Cache the metadata
+    gitMetadataCache.set(filePath, metadata);
+
+    // IMPORTANT: Return a NEW object, not the cached one
+    // This prevents all pages from sharing the same object reference
+    return {
+      commitHash: metadata.commitHash,
+      author: metadata.author,
+      timestamp: metadata.timestamp,
+    };
+  } catch (error) {
+    // Git command failed or file doesn't exist in git
+    gitMetadataCache.set(filePath, null);
+    return null;
+  }
+}